Package com.google.nigori.client

Examples of com.google.nigori.client.NigoriDatastore


              "jlkvjhskldhjvguyvh78ryfgkjvjhzsahkjrtgagflbakjsdvskjhsjkhdafkjdashlkjajhasfkjsadhf;adshfkjd",
              false)};

  @Test
  public void setGetDelete() throws NigoriCryptographyException, IOException, UnauthorisedException {
    NigoriDatastore nigori = getStore();

    for (int i = 0; i < AcceptanceTests.REPEAT; ++i) {// check we can do this more than once
      try {
        assertTrue("Not registered" + i, nigori.register());
        assertTrue("Not a clean store " + i, nigori.getIndices().isEmpty());

        for (IndexValue iv : testCases) {// once round for each
          final Index index = iv.index;
          final Revision revision = iv.revvalue.getRevision();
          final byte[] value = iv.revvalue.getValue();

          assertTrue("Not put " + i, nigori.put(index, revision, value));
          List<RevValue> revs = nigori.get(index);
          assertFalse("Revisions must exist" + i, revs.isEmpty());
          assertThat(revs, hasItem(iv.revvalue));
          assertEquals("Not one revision " + i, 1, revs.size());
          assertTrue("Not deleted" + i, nigori.delete(index, NULL_DELETE_TOKEN));
          assertNull("Not deleted" + i, nigori.get(index));
          assertFalse("Could redelete", nigori.delete(index, NULL_DELETE_TOKEN));
        }
        // allow them to accumulate
        for (IndexValue iv : testCases) {
          final Index index = iv.index;
          final byte[] value = iv.revvalue.getValue();
          final Revision revision = iv.revvalue.getRevision();
          assertTrue("Not put" + i, nigori.put(index, revision, value));
        }
        try {
          for (IndexValue iv : testCases) {
            final Index index = iv.index;
            final byte[] value = iv.revvalue.getValue();
            final Revision revision = iv.revvalue.getRevision();
            assertArrayEquals("Got different" + i, value, nigori.getRevision(index, revision));
          }
        } finally {
          for (IndexValue iv : testCases) {
            final Index index = iv.index;
            if (!iv.later) {
              assertTrue("Not deleted" + i, nigori.delete(index, NULL_DELETE_TOKEN));
            } else {// should have already been deleted
              assertFalse("Not deleted" + i, nigori.delete(index, NULL_DELETE_TOKEN));
            }
          }
        }
        for (IndexValue iv : testCases) {
          final Index index = iv.index;
          assertNull("Still there after deletion " + i, nigori.get(index));
        }
      } finally {
        assertTrue("Not unregistered", nigori.unregister());
      }
    }
  }
View Full Code Here


    }
  }

  @Test
  public void getRevisions() throws IOException, NigoriCryptographyException, UnauthorisedException {
    NigoriDatastore nigori = getStore();
    try {
      assertTrue("Not registered", nigori.register());
      final Index index = new Index("index");
      final Revision a = new Revision("a");
      final Revision b = new Revision("b");
      assertTrue("Not put", nigori.put(index, a, toBytes("aa")));
      assertTrue("Not put", nigori.put(index, b, toBytes("bb")));
      try {
        List<Revision> revisions = nigori.getRevisions(index);
        assertNotNull("No revisions", revisions);
        assertEquals("Not correct number of revisions", 2, revisions.size());
        assertThat(revisions, hasItem(a));
        assertThat(revisions, hasItem(b));
      } finally {
        nigori.delete(index, NULL_DELETE_TOKEN);
      }
    } finally {
      assertTrue("Not unregistered", nigori.unregister());
    }
  }
View Full Code Here

    }
  }

  @Test
  public void getIndices() throws IOException, NigoriCryptographyException, UnauthorisedException {
    NigoriDatastore nigori = getStore();
    try {
      assertTrue("Not registered", nigori.register());
      final Index indexa = new Index("indexa");
      final Index indexb = new Index("indexb");
      final Revision revision = new Revision("a");
      assertTrue("Not put", nigori.put(indexa, revision, toBytes("aa")));
      assertTrue("Not put", nigori.put(indexb, revision, toBytes("bb")));
      try {
        List<Index> indices = nigori.getIndices();
        assertNotNull("No indices", indices);
        assertEquals("Not correct number of indices", 2, indices.size());
        assertThat(indices, hasItem(indexa));
        assertThat(indices, hasItem(indexb));
      } finally {
        nigori.delete(indexa, NULL_DELETE_TOKEN);
        nigori.delete(indexb, NULL_DELETE_TOKEN);
      }
    } finally {
      assertTrue("Not unregistered", nigori.unregister());
    }
  }
View Full Code Here

  // @Test //TODO(drt24) Do we want to enforce revisions being immutable? Migori doesn't really need
  // this due to the way revisions are generated.
  public void immutableRevisions() throws IOException, NigoriCryptographyException,
      UnauthorisedException {
    NigoriDatastore nigori = getStore();
    try {
      assertTrue("Not registered", nigori.register());
      final Index index = new Index("index");
      final Revision revision = new Revision("rev");
      assertTrue("Not put", nigori.put(index, revision, Util.int2bin(0)));
      assertFalse("Could replace revision value", nigori.put(index, revision, Util.int2bin(1)));
      nigori.delete(index, NULL_DELETE_TOKEN);
    } finally {
      assertTrue("Not unregistered", nigori.unregister());
    }
  }
View Full Code Here

      threads[j] = new Thread() {
        @Override
        public void run() {
          boolean succeeded = false;
          try {
            NigoriDatastore nigori = getStore();

            for (int i = 0; i < AcceptanceTests.REPEAT * REPEAT_FACTOR; ++i) {
              // check we can do this more than once
              assertTrue("Not registered" + i, nigori.register());
              try {
                for (IndexValue iv : SetGetDeleteTest.testCases) {// once round for each
                  final Index index = iv.index;
                  final byte[] value = iv.revvalue.getValue();
                  final Revision revision = iv.revvalue.getRevision();
                  assertTrue("Not put" + i, nigori.put(index, revision, value));
                  assertArrayEquals("Got different" + i, value, nigori.getRevision(index, revision));
                  assertTrue("Not deleted " + i, nigori.delete(index, NULL_DELETE_TOKEN));
                  assertNull("Still there after deletion " + i, nigori.get(index));
                }
              } finally {
                assertTrue(nigori.unregister());
              }
            }
            succeeded = true;
          } catch (Throwable e) {
            exceptionList.add(e);
View Full Code Here

  public void singleUserConcurrency() throws NigoriCryptographyException, IOException,
      UnauthorisedException {
    failed = false;
    Thread[] threads = new Thread[THREADS];

    final NigoriDatastore nigori = getStore();
    assertTrue("Not registered", nigori.register());
    try {
      final List<Throwable> exceptionList =
          Collections.synchronizedList(new LinkedList<Throwable>());
      for (int j = 0; j < THREADS; ++j) {
        threads[j] = new Thread() {
          @Override
          public void run() {
            boolean succeeded = false;
            try {
              Random r = new Random();
              for (int i = 0; i < AcceptanceTests.REPEAT * REPEAT_FACTOR; ++i) {
                // check we can do this more than once
                for (IndexValue iv : SetGetDeleteTest.testCases) {// once round for each
                  final Index index = new Index(new byte[16]);
                  r.nextBytes(index.getBytes());// need to generate some different indices
                  final byte[] value = iv.revvalue.getValue();
                  final Revision revision = iv.revvalue.getRevision();
                  assertTrue("Not put" + i, nigori.put(index, revision, value));
                  try {
                    assertArrayEquals("Got different" + i, value, nigori.getRevision(index,
                        revision));
                  } finally {
                    assertTrue("Not deleted" + i, nigori.delete(index, NULL_DELETE_TOKEN));
                  }
                  assertNull("Not deleted" + i, nigori.get(index));
                }
              }
              succeeded = true;
            } catch (Throwable e) {
              exceptionList.add(e);
            } finally {
              if (!succeeded && !failed) {
                failed = true;
              }
            }
          }
        };
      }
      startThenJoinThreads(threads);

      ifFailedPrintFailures(failed, exceptionList);
    } finally {
      assertTrue(nigori.unregister());
    }
  }
View Full Code Here

TOP

Related Classes of com.google.nigori.client.NigoriDatastore

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.