import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void currentUser_AuthorizedRequest_Ok() {

    User user = new User("[email protected]", "password", "John", "Doe");
    user.save();

    Result result = callAction(routes.ref.UserController.currentUser(),
            authorizeRequest(fakeRequest(), user));
    assertThat(status(result)).isEqualTo(Http.Status.OK);

    try {
        JsonNode responseJson = JsonHelper.removeRootElement(Json.parse(contentAsString(result)), User.class, false);
        assertThat(Json.fromJson(responseJson, User.class)).isEqualTo(user);
    } catch (JsonHelper.InvalidJSONException e) {
        e.printStackTrace();
        Fail.fail(e.getMessage());
    }
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void shouldBuildAndApplyCreationPatch() {
    //Testing.Print.enable();
    
    Document initial = Document.create("firstName", "Jackie", "lastName", "Jones");
    Patch<EntityId> patch = Patch.create(ENTITY_ID, initial);
    assertThat(patch.isCreation()).isTrue();
    
    Document result = Document.create();
    patch.apply(result, (path,op)->Fail.fail("Unable to apply op"));
    Testing.print("patch = " + patch);
    Testing.print("result = " + result);
    assertThat(result.getString("firstName")).isEqualTo("Jackie");
    assertThat(result.getString("lastName")).isEqualTo("Jones");
    assertThat(Message.getId(result)).isEqualTo(ENTITY_ID);
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void shouldBuildAndApplyPatchToAddSimpleFieldsToEntity() {
    //Testing.Print.enable();
    
    Patch<EntityId> patch = Patch.edit(ENTITY_ID)
            .add("firstName", Value.create("Jackie"))
            .add("lastName", Value.create("Jones"))
            .end();
    assertThat(patch.isCreation()).isFalse();

    // Apply the patch ....
    Document doc = Document.create();
    Message.addId(doc, ENTITY_ID);
    patch.apply(doc, (path,op)->Fail.fail("Unable to apply patch: " + op));
    Testing.print("patch = " + patch);
    Testing.print("doc = " + doc);
    
    assertThat(doc.getString("firstName")).isEqualTo("Jackie");
    assertThat(doc.getString("lastName")).isEqualTo("Jones");
    assertThat(Message.getId(doc)).isEqualTo(ENTITY_ID);
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void shouldBuildAndApplyPatchToAddSimpleAndDocumentFieldsToEntity() {
    //Testing.Print.enable();
    
    Patch<EntityId> patch = Patch.edit(ENTITY_ID)
            .add("firstName", Value.create("Jackie"))
            .add("lastName", Value.create("Jones"))
            .add("address", Value.create(Document.create("street","123 Main","city","Springfield")))
            .end();
    assertThat(patch.isCreation()).isFalse();

    // Apply the patch ....
    Document doc = Document.create();
    Message.addId(doc, ENTITY_ID);
    patch.apply(doc, (path,op)->Fail.fail("Unable to apply patch: " + op));
    Testing.print("patch = " + patch);
    Testing.print("doc = " + doc);
    
    assertThat(Message.getId(doc)).isEqualTo(ENTITY_ID);
    assertThat(doc.getString("firstName")).isEqualTo("Jackie");
    assertThat(doc.getString("lastName")).isEqualTo("Jones");
    Document address = doc.getDocument("address");
    assertThat(address.getString("street")).isEqualTo("123 Main");
    assertThat(address.getString("city")).isEqualTo("Springfield");
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void directDeleteProperty() throws Exception {
    String methodName = "testDirectDeleteProperty";
    assertThat(db.getCollectionNames().contains(methodName)).isFalse();

    // create the object using the mongo driver directly
    BasicDBObject object = new BasicDBObject();
    object.append("foo", new BasicDBObject("bar", "123"));
    db.getCollection(methodName).insert(object);
    String id = object.getObjectId("_id").toString();
    assertThat(db.getCollection(methodName).findOne(new BasicDBObject("_id", new ObjectId(id)))).isNotNull();

    // we should not be able to directly delete a child property
    try {
        client.delete(new RequestContext.Builder().build(), "/testApp/" + BASEPATH + "/" + methodName + "/" + id + "/foo");
        Fail.fail("We should not be able to directly delete a property");
    } catch (ResourceNotFoundException e) {
        // expected
    }

    assertThat((DBObject) object).isEqualTo(db.getCollection(methodName).findOne());
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void deleteChildObject() throws Exception {
    String methodName = "testDeleteChildObject";
    assertThat(db.getCollectionNames().contains(methodName)).isFalse();

    // create the object using the mongo driver directly
    BasicDBObject object = new BasicDBObject();
    object.append("foo", new BasicDBObject("bar", new BasicDBObject("ABC", 123)));
    db.getCollection(methodName).insert(object);
    String id = object.getObjectId("_id").toString();
    assertThat(db.getCollection(methodName).findOne(new BasicDBObject("_id", new ObjectId(id)))).isNotNull();

    // we should not be able to directly delete a child object
    try {
        client.delete(new RequestContext.Builder().returnFields(new DefaultReturnFields("bar(ABC(*))")).build(), "/testApp/" + BASEPATH + "/" + methodName
                + "/" + id + "/foo");
        Fail.fail("We should not be able to directly delete a child object");
    } catch (ResourceNotFoundException e) {
        // expected
    }

    assertThat((DBObject) object).isEqualTo(db.getCollection(methodName).findOne());
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void deleteChildProperty() throws Exception {
    String methodName = "testDeleteChildProperty";
    assertThat(db.getCollectionNames().contains(methodName)).isFalse();

    // create the object using the mongo driver directly
    BasicDBObject object = new BasicDBObject();
    object.append("foo", new BasicDBObject("bar", new BasicDBObject("ABC", 123)));
    db.getCollection(methodName).insert(object);
    String id = object.getObjectId("_id").toString();
    assertThat(db.getCollection(methodName).findOne(new BasicDBObject("_id", new ObjectId(id)))).isNotNull();

    // we should not be able to directly delete a child property
    try {
        client.delete(new RequestContext.Builder().build(), "/testApp/" + BASEPATH + "/" + methodName + "/" + id + "/foo/bar");
        Fail.fail("We should not be able to directly delete a property on a child object");
    } catch (ResourceNotFoundException e) {
        // expected
    }

    assertThat((DBObject) object).isEqualTo(db.getCollection(methodName).findOne());
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void deleteGrandchildObject() throws Exception {
    String methodName = "testDeleteGrandchildObject";
    assertThat(db.getCollectionNames().contains(methodName)).isFalse();

    // create the object using the mongo driver directly
    BasicDBObject object = new BasicDBObject();
    object.append("foo", new BasicDBObject("bar", new BasicDBObject("ABC", new BasicDBObject("123", "XYZ"))));
    db.getCollection(methodName).insert(object);
    String id = object.getObjectId("_id").toString();
    assertThat(db.getCollection(methodName).findOne(new BasicDBObject("_id", new ObjectId(id)))).isNotNull();

    // we should not be able to directly delete a child object
    try {
        client.delete(new RequestContext.Builder().returnFields(new DefaultReturnFields("bar(ABC(*))")).build(), "/testApp/" + BASEPATH + "/" + methodName
                + "/" + id + "/foo");
        Fail.fail();
    } catch (ResourceNotFoundException e) {
        // expected
    }

    assertThat((DBObject) object).isEqualTo(db.getCollection(methodName).findOne());
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void getChildDirectly() throws Exception {
    String methodName = "testGetChildDirectly";
    assertThat(db.collectionExists(methodName)).isFalse();

    // create the object using the mongo driver directly
    BasicDBObject object = new BasicDBObject();
    object.append("foo", "bar").append("abc", "123").append("obj", new BasicDBObject("foo2", "bar2"));
    object.append("child", new BasicDBObject("grandchild", new BasicDBObject("foo3", "bar3")));
    db.getCollection(methodName).insert(object);
    assertEquals(1, db.getCollection(methodName).getCount());
    String id = "ObjectId(\"" + object.getObjectId("_id").toString() + "\")";

    try {
        client.read(new RequestContext.Builder().build(), "/testApp/" + BASEPATH + "/" + methodName + "/" + id + "/child");
        Fail.fail();
    } catch (ResourceNotFoundException e) {
        // expected
    }
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void getCollection() throws Exception {
    String methodName = "testGetCollection";
    assertThat(db.collectionExists(methodName)).isFalse();

    // create the object using the mongo driver directly
    BasicDBObject object = new BasicDBObject("_id", "foobaz");

    BasicDBList list = new BasicDBList();
    list.add(1);
    list.add("A");
    list.add(new BasicDBObject("_id", "test123").append("foo", "bar"));
    object.append("array", list);

    db.getCollection(methodName).insert(object);
    assertEquals(1, db.getCollection(methodName).getCount());

    try {
        client.read(new RequestContext.Builder().build(), "/testApp/" + BASEPATH + "/" + methodName + "/foobaz/array");
        Fail.fail();
    } catch (ResourceNotFoundException e) {
        // expected
    }
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void getEmptyCollection() throws Exception {
    String methodName = "testEmptyCollection";
    // check that the collection really is empty
    assertFalse(db.collectionExists(methodName));

    try {
        client.read(new RequestContext.Builder().build(), "/testApp/" + BASEPATH + "/" + methodName);
        Fail.fail();
    } catch (ResourceNotFoundException e) {
        // expected
    }

    db.createCollection(methodName, new BasicDBObject());

    ResourceState result = client.read(new RequestContext.Builder().build(), "/testApp/" + BASEPATH + "/" + methodName);

    // verify the result
    assertThat(result.id()).isEqualTo(methodName);
    assertThat(result.getProperty("type")).isEqualTo("collection");
    assertThat(result.members()).isEmpty();

    // check that the collection is still empty
    assertEquals(0, db.getCollection(methodName).getCount());
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void getStorageCollectionsInvalidQueryString() throws Exception {
    DBCollection collection = db.getCollection("testQueryCollectionInvalid");
    if (collection != null) {
        collection.drop();
    }
    collection = db.createCollection("testQueryCollectionInvalid", new BasicDBObject("count", 0));

    // insert data records for the test
    setupPeopleData(collection);
    assertThat(collection.count()).isEqualTo(6);

    // This should return 2 items
    SimpleResourceParams resourceParams = new SimpleResourceParams();
    resourceParams.put("q", "{lastName,\"foo\"}");
    RequestContext requestContext = new RequestContext.Builder().returnFields(new DefaultReturnFields("*(*)")).resourceParams(resourceParams).build();

    try {
        client.read(requestContext, "/testApp/" + BASEPATH + "/testQueryCollectionInvalid");
        Fail.fail();
    } catch (NotAcceptableException iee) {
        // TODO fix me
        //assertThat(iee.message()).isEqualTo("Invalid JSON format for the 'query' parameter");
        //assertThat(iee.getCause().getClass().getName()).isEqualTo("com.mongodb.util.JSONParseException");
    }
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void childDirectUpdate() throws Exception {
    String methodName = "testChildDirectUpdate";
    assertThat(db.getCollection(methodName).getCount()).isEqualTo(0);

    // create the object using the mongo driver directly
    BasicDBObject object = new BasicDBObject();
    object.append("foo", new BasicDBObject("bar", "baz"));
    db.getCollection(methodName).insert(object);
    assertEquals(1, db.getCollection(methodName).getCount());
    String id = "ObjectId(\"" + object.getObjectId("_id").toString() + "\")";

    // update the resource using the client.update method
    ResourceState resourceState = new DefaultResourceState();
    resourceState.putProperty("bar", 123);

    // should not be able to directly update a child object
    try {
        client.update(new RequestContext.Builder().build(), "/testApp/" + BASEPATH + "/" + methodName + "/" + id + "/foo", resourceState);
        Fail.fail();
    } catch (CreateNotSupportedException e) {
        // expected
    }

    assertThat((DBObject) object).isEqualTo(db.getCollection(methodName).findOne());
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void grandchildDirectUpdate() throws Exception {
    String methodName = "testGrandChildDirectUpdate";
    assertThat(db.getCollection(methodName).getCount()).isEqualTo(0);

    // create the object using the mongo driver directly
    BasicDBObject object = new BasicDBObject();
    object.append("foo", new BasicDBObject("bar", new BasicDBObject("baz", "ABC")));
    db.getCollection(methodName).insert(object);
    assertEquals(1, db.getCollection(methodName).getCount());
    String id = "ObjectId(\"" + object.getObjectId("_id").toString() + "\")";

    // update the resource using the client.update method
    ResourceState resourceState = new DefaultResourceState();
    resourceState.putProperty("baz", "XYZ");

    try {
        client.update(new RequestContext.Builder().build(), "/testApp/" + BASEPATH + "/" + methodName + "/" + id + "/foo/bar", resourceState);
        Fail.fail();
    } catch (ResourceNotFoundException e) {
        // expected
    }

    assertThat((DBObject) object).isEqualTo(db.getCollection(methodName).findOne());
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void invalidType() throws Exception {
    ResourceState config = new DefaultResourceState();
    config.putProperty("db", "testInvalidTypeDB");
    config.putProperty("servers", new ArrayList());

    ResourceState configReadPref = new DefaultResourceState();
    configReadPref.putProperty(ReadPreferenceState.TYPE, "foobar");
    config.putProperty(ReadPreferenceState.ID, configReadPref);

    try {
        setUpSystem(config);
        Fail.fail();
    } catch (InitializationException e) {
        //expected
    }
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void renameCollectionAlreadyExists() throws Exception {
    db.dropDatabase(); // TODO: create a new DB here instead of dropping the old one
    assertThat(db.getCollectionNames()).hasSize(0);

    // create a couple of collections
    db.createCollection("foo", new BasicDBObject());
    db.createCollection("bar", new BasicDBObject());

    // check that the collections are there (Note: there is an internal index collection, so one more than expected)
    assertThat(db.getCollectionNames()).hasSize(3);
    assertThat(db.collectionExists("foo"));
    assertThat(db.collectionExists("bar"));

    // set the update resource state to include a new id value
    // Note that this matches an already existing collection
    ResourceState updateResourceState = new DefaultResourceState("bar");

    try {
        client.update(new RequestContext.Builder().build(), "/testApp/" + BASEPATH + "/foo", updateResourceState);
        Fail.fail();
    } catch (ResourceAlreadyExistsException e) {
        //expected
    }
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void updateProperty() throws Exception {
    db.dropDatabase(); // TODO: create a new DB here instead of dropping the old one
    assertThat(db.getCollectionNames()).hasSize(0);

    // create a collection
    DBCollection collection = db.createCollection("foo", new BasicDBObject());
    DBObject dbObject = new BasicDBObject("_id", "testObject");
    dbObject.put("hello", "world");
    collection.insert(dbObject);

    // check that the collection is there (Note: there is an internal index collection, so one more than expected)
    assertThat(db.getCollectionNames()).hasSize(2);
    assertThat(db.getCollection("foo").count() == 1);

    // set the update resource state to include the same id value
    ResourceState updateResourceState = new DefaultResourceState();
    updateResourceState.putProperty("count", 500L);

    try {
        client.update(new RequestContext.Builder().build(), "/testApp/" + BASEPATH + "/foo", updateResourceState);
        Fail.fail();
    } catch (NotAcceptableException e) {
        //expected
    }
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void deleteElementCappedCollection() throws Exception {
    // check that we can create the resource
    ResourceState state = new DefaultResourceState("onlyThree");
    state.putProperty("capped", "true");
    state.putProperty("size", 1024);
    state.putProperty("max", 3);

    ResourceState createdResource = client.create(new RequestContext.Builder().build(), "/testApp/storage", state);
    assertThat(createdResource).isNotNull();
    assertThat(createdResource.id()).isEqualTo("onlyThree");

    client.create(new RequestContext.Builder().build(), "/testApp/storage/onlyThree", new DefaultResourceState("first"));

    // this should fail since you cannot delete from a capped collection
    try {
        client.delete(new RequestContext.Builder().build(), "/testApp/storage/onlyThree/first");
        Fail.fail();
    } catch (DeleteNotSupportedException dnse) {
        //expected
    }
}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Test
public void testInvalidObjectType() throws Exception {
    DefaultResourceState state = new DefaultResourceState();
    Object invalid = new Object();
    state.putProperty("invalid", invalid );

    InMemoryObjectResource resource = new InMemoryObjectResource(null, "bob", state);

    CompletableFuture<ResourceState> future = new CompletableFuture<>();
    EncodingDriver driver = createDriver(resource, future);

    try {
        driver.encode();
        Fail.fail();
    } catch (NonEncodableValueException e) {
        //expected
        assertThat( e.getValue() ).isSameAs( invalid );
    }

}
 

import org.fest.assertions.Fail; //导入依赖的package包/类
@Override
public boolean matches(final File file) {

    try {
        return FileUtils.readFileToString(file).contains(expectedContent);
    } catch (final IOException e) {
        Fail.fail("could not check file contents", e);
        return false;
    }
}