@Test public void testNewEntry() { E e2 = database.newEntry(); Assert.assertNull(e2.getParent()); assertEquals("", e2.getPassword()); Assert.assertNotNull(e2.getUuid()); assertEquals("", e2.getUrl()); assertEquals("", e2.getNotes()); assertEquals("", e2.getUsername()); assertEquals("", e2.getTitle()); Assert.assertNull(e2.getProperty("silly")); List<String> l = e2.getPropertyNames(); l.removeAll(Entry.STANDARD_PROPERTY_NAMES); Assert.assertEquals(0, l.size()); }
@Override public E newEntry(Entry<?,?,?,?> entry) { E result = newEntry(); for (String propertyName: entry.getPropertyNames()) { try { // all implementations must support setting of STANDARD_PROPERTY_NAMES result.setProperty(propertyName, entry.getProperty(propertyName)); } catch (UnsupportedOperationException e) { // oh well, we tried } } try { for (String propertyName: (entry.getBinaryPropertyNames())) { try { // all implementations must support setting of STANDARD_PROPERTY_NAMES result.setBinaryProperty(propertyName, entry.getBinaryProperty(propertyName)); } catch (UnsupportedOperationException e) { // oh well, we tried } } } catch (UnsupportedOperationException e) { // never mind } result.setIcon(this.newIcon(entry.getIcon().getIndex())); // everything else should have been copied via properties return result; }
private E entryFactory(D database, String g, int e) { E result = database.newEntry(); result.setTitle(g + "-" + e); result.setUsername(g + " - un - " + e); result.setPassword(g + "- p -" + e); result.setUrl(g + "- url - " + e); result.setNotes(g + "- n - " + e); return result; }
public void process(Message.Request r, Message.Response resp) { @SuppressWarnings("unchecked") List<Entry> entries = database.findEntries(new Entry.Matcher() { @Override public boolean matches(Entry entry) { return true; } }); for (Entry entry : entries) { resp.Entries.add(new ResponseEntry(entry.getTitle(), entry.getUsername(), entry.getPassword(), entry.getUuid().toString())); } resp.Count = resp.Entries.size(); resp.Success = true; } }
@Test public void testSetFields () { E e1 = database.newEntry("Entry 1"); e1.setNotes("this looks a little like Entry 2"); Assert.assertTrue(e1.getNotes().equals("this looks a little like Entry 2")); e1.setUsername("jake@window.com"); Assert.assertTrue(e1.getUsername().equals("jake@window.com")); e1.setPassword("supercalifragelisticexpialidocious"); Assert.assertTrue(e1.getPassword().equals("supercalifragelisticexpialidocious")); e1.setUrl("http://window.com"); Assert.assertTrue(e1.getUrl().equals("http://window.com")); Assert.assertTrue(e1.match("2")); Assert.assertTrue(e1.matchTitle("1")); Assert.assertFalse(e1.matchTitle("doggy")); e1.setIcon(ic1); Assert.assertTrue(e1.getIcon().equals(ic1)); e1.setProperty(Entry.STANDARD_PROPERTY_NAME_TITLE, "A title"); assertEquals("A title", e1.getTitle()); e1.setProperty(Entry.STANDARD_PROPERTY_NAME_USER_NAME, "username"); assertEquals("username", e1.getUsername()); e1.setProperty(Entry.STANDARD_PROPERTY_NAME_NOTES, "notes"); assertEquals("notes", e1.getNotes()); e1.setProperty(Entry.STANDARD_PROPERTY_NAME_PASSWORD, "password"); assertEquals("password", e1.getPassword()); e1.setProperty(Entry.STANDARD_PROPERTY_NAME_URL, "url"); assertEquals("url", e1.getUrl());
@Test public void testCopy() throws IOException { E entry1 = database.newEntry(); entry1.setTitle("Entry"); entry1.setUsername("Username"); entry1.setPassword("Password"); entry1.setUrl("http://dont.follow.me"); entry1.setNotes("Notes"); entry1.setIcon(database.newIcon(2)); assertEquals(entry1.getTitle(), entry2.getTitle()); assertEquals(entry1.getUsername(), entry2.getUsername()); assertEquals(entry1.getPassword(), entry2.getPassword()); assertEquals(entry1.getUrl(), entry2.getUrl()); assertEquals(entry1.getNotes(), entry2.getNotes()); assertEquals(entry1.getIcon(), entry2.getIcon()); assertNotEquals(entry1.getUuid(), entry2.getUuid());
entry1.setTitle("A new entry"); assertEquals("A new entry", entry1.getTitle()); entry1.setUsername("user name"); assertEquals("user name", entry1.getUsername()); entry1.setProperty("random", "new"); assertEquals("new", entry1.getProperty("random")); entry1.setProperty("random", "old"); assertEquals("old", entry1.getProperty("random")); entry1.setPassword("pass"); assertEquals("pass", entry1.getPassword()); entry2.setPassword("pass2"); assertEquals("pass2", entry2.getPassword()); group2.addEntry(entry2);
entry.setTitle("New Entry " + format.format(new Date())); entry.setNotes("Created automatically"); } else { entry.setNotes(entry.getNotes() + "\nUpdated " + format.format(new Date())); entry.setPassword(r.Password); entry.setUsername(r.Login); entry.setUrl(r.Url); entry.setProperty("SubmitUrl", r.SubmitUrl);
for (int e = 0; e <= g; e++) { Entry entry = (Entry) group.getEntries().get(e); assertEquals(g + "-" + e, entry.getTitle()); assertEquals(g + " - un - " + e, entry.getUsername()); assertEquals(g + "- p -" + e, entry.getPassword()); assertEquals(g + "- url - " + e, entry.getUrl()); assertEquals(g + "- n - " + e, entry.getNotes()); assertEquals(group, entry.getParent());
@Test public void checkAddChangeRemoveProperty() { // only applies to databases that support arbitrary properties E entry = database.newEntry(); assertEquals(Entry.STANDARD_PROPERTY_NAMES.size(), entry.getPropertyNames().size()); try { entry.setProperty("test", "test1"); } catch (UnsupportedOperationException e) { if (!database.supportsNonStandardPropertyNames()) { return; } fail("Database must report that it doesn't support non standrad properties"); } assertEquals("test1", entry.getProperty("test")); entry.setProperty("test", "test2"); assertEquals("test2", entry.getProperty("test")); assertTrue(entry.removeProperty("test")); assertFalse(entry.removeProperty("test")); assertFalse(entry.removeProperty("test-test")); assertEquals(Entry.STANDARD_PROPERTY_NAMES.size(), entry.getPropertyNames().size()); try { entry.removeProperty(Entry.STANDARD_PROPERTY_NAME_USER_NAME); fail("Should not be able to remove standard property"); } catch (IllegalArgumentException ignore) { // ignore as expected } }
@Test public void checkAddChangeRemoveBinaryProperty() { byte[] test = new byte[] {0, 1, 2 ,3}; byte[] test2 = new byte[] {3, 2, 1, 0}; Entry entry = database.findEntries("Test attachment").get(0); assertEquals(1, entry.getBinaryPropertyNames().size()); entry.setBinaryProperty("test", test); assertArrayEquals(test, entry.getBinaryProperty("test")); entry.setBinaryProperty("test", test2); assertArrayEquals(test2, entry.getBinaryProperty("test")); // true that property was removed assertTrue(entry.removeBinaryProperty("test")); // false that same property was removed assertFalse(entry.removeBinaryProperty("test")); // false that non existent was removed assertFalse(entry.removeBinaryProperty("test-test")); // same number of properties as we started with assertEquals(1, entry.getBinaryPropertyNames().size()); } }
@Test public void setBinaryProperty() throws Exception { InputStream testfile = getClass().getClassLoader().getResourceAsStream("letter L.jpeg"); byte [] original = ByteStreams.toByteArray(testfile); Entry entry = database.findEntries("Test attachment").get(0); entry.setBinaryProperty("letter L.jpeg", original); byte [] letterL = entry.getBinaryProperty("letter L.jpeg"); Assert.assertArrayEquals(original, letterL); assertArrayEquals(new String[] {"letter J.jpeg", "letter L.jpeg"}, entry.getBinaryPropertyNames().toArray()); Assert.assertTrue(database.isDirty()); }
@Test public void testAddRemoveEntry() { E e1 = database.getRootGroup().addEntry(database.newEntry()); e1.setTitle("entry1"); List<? extends E> l1 = database.findEntries("entry1"); Assert.assertTrue(l1.size() == 1); E e12 = database.getRootGroup().addEntry(database.newEntry("entry12")); List<? extends E> l2 = database.findEntries("entry1"); Assert.assertTrue(l2.size() == 2); // show that the entries are different Assert.assertFalse(l2.get(0).equals(l2.get(1))); // show that the list is a copy l2.clear(); Assert.assertTrue(database.findEntries("entry1").size() == 2); // show that we get an equivalent entry when we remove to when we inserted Entry e12b = database.getRootGroup().removeEntry(e12); Assert.assertTrue(e12b.equals(e12)); // has been unhooked from parent Assert.assertTrue(e12.getParent() == null); Assert.assertTrue(database.findEntries("entry1").size() == 1); }
@Override public boolean matches(Entry entry) { return entry.getUuid().equals(uuid); } });
System.out.println(tes.getTitle()); String pass = tests.get(0).getPassword(); String pass2 = tests.get(0).getPassword(); Assert.assertEquals(pass, pass2); Assert.assertEquals("123", pass2); Assert.assertEquals(4, passwords.size()); for (Entry passwordEntry : passwords) { assertEquals(passwordEntry.getTitle(), passwordEntry.getPassword()); System.out.println(passwordEntry.getTitle()); assertEquals("pass", entries.get(0).getPassword());
@Override public boolean matches(Entry entry) { return entry.getProperty(Entry.STANDARD_PROPERTY_NAME_TITLE).toLowerCase().contains("findme!"); } });
@Override public E newEntry(String title) { E result = newEntry(); result.setTitle(title); return result; }
@Test public void getBinaryProperty() throws Exception { Entry entry = database.findEntries("Test attachment").get(0); byte [] letterJ = entry.getBinaryProperty("letter J.jpeg"); InputStream testfile = getClass().getClassLoader().getResourceAsStream("letter J.jpeg"); byte [] original = ByteStreams.toByteArray(testfile); Assert.assertArrayEquals(original, letterJ); }
@Test public void getBinaryPropertyNames() throws Exception { Entry entry = database.findEntries("Test attachment").get(0); assertArrayEquals(new String[] {"letter J.jpeg"}, entry.getBinaryPropertyNames().toArray()); entry = database.findEntries("Test 2 attachment").get(0); assertArrayEquals(new String[] {"letter J.jpeg", "letter L.jpeg"}, entry.getBinaryPropertyNames().toArray()); }
@Override public boolean deleteEntry(final UUID uuid) { E e = findEntry(uuid); if (e == null) { return false; } e.getParent().removeEntry(e); if (isRecycleBinEnabled()) { getRecycleBin().addEntry(e); } return true; }