@Test(groups = {"basic"})
public void testSnapshot() {
DBCollection c = _db.getCollection("snapshot1");
c.drop();
for (int i = 0; i < 100; i++) c.save(new BasicDBObject("x", i));
assertEquals(100, c.find().count());
assertEquals(100, c.find().toArray().size());
assertEquals(100, c.find().snapshot().count());
assertEquals(100, c.find().snapshot().toArray().size());
assertEquals(100, c.find().snapshot().limit(50).count());
assertEquals(50, c.find().snapshot().limit(50).toArray().size());
}
@Test
public void testSpecial() {
DBCollection c = _db.getCollection("testSpecial");
c.insert(new BasicDBObject("x", 1));
c.insert(new BasicDBObject("x", 2));
c.insert(new BasicDBObject("x", 3));
c.ensureIndex("x");
for (DBObject o : c.find().sort(new BasicDBObject("x", 1)).addSpecial("$returnKey", 1))
assertTrue(o.get("_id") == null);
for (DBObject o : c.find().sort(new BasicDBObject("x", 1))) assertTrue(o.get("_id") != null);
}
@Test
public void testExplain() {
DBCollection c = _db.getCollection("explain1");
c.drop();
for (int i = 0; i < 100; i++) c.save(new BasicDBObject("x", i));
DBObject q = BasicDBObjectBuilder.start().push("x").add("$gt", 50).get();
assertEquals(49, c.find(q).count());
assertEquals(49, c.find(q).itcount());
assertEquals(49, c.find(q).toArray().size());
assertEquals(49, c.find(q).itcount());
assertEquals(20, c.find(q).limit(20).itcount());
assertEquals(20, c.find(q).limit(-20).itcount());
c.ensureIndex(new BasicDBObject("x", 1));
assertEquals(49, c.find(q).count());
assertEquals(49, c.find(q).toArray().size());
assertEquals(49, c.find(q).itcount());
assertEquals(20, c.find(q).limit(20).itcount());
assertEquals(20, c.find(q).limit(-20).itcount());
assertEquals(49, c.find(q).explain().get("n"));
assertEquals(20, c.find(q).limit(20).explain().get("n"));
assertEquals(20, c.find(q).limit(-20).explain().get("n"));
}
public static void main(String[] args) throws UnknownHostException {
MongoClient client = new MongoClient();
DB db = client.getDB("course");
DBCollection lines = db.getCollection("dotNotationTest");
lines.drop();
Random rand = new Random();
for (int i = 0; i < 10; i++) {
lines.insert(
new BasicDBObject("_id", i)
.append(
"start",
new BasicDBObject("x", rand.nextInt(90) + 10).append("y", rand.nextInt(90) + 10))
.append(
"end",
new BasicDBObject("x", rand.nextInt(90) + 10)
.append("y", rand.nextInt(90) + 10)));
}
QueryBuilder builder = QueryBuilder.start("start.x").greaterThan(50);
DBCursor cursor =
lines.find(builder.get(), new BasicDBObject("start.y", true).append("_id", false));
try {
while (cursor.hasNext()) {
DBObject cur = cursor.next();
System.out.println(cur);
}
} finally {
cursor.close();
}
}
@Test
public void testBatchWithActiveCursor() {
DBCollection c = _db.getCollection("testBatchWithActiveCursor");
c.drop();
for (int i = 0; i < 100; i++) c.save(new BasicDBObject("x", i));
try {
DBCursor cursor = c.find().batchSize(2); // setting to 1, actually sets to 2 (why, oh why?)
cursor.next(); // creates real cursor on server.
cursor.next();
assertEquals(0, cursor.numGetMores());
cursor.next();
assertEquals(1, cursor.numGetMores());
cursor.next();
cursor.next();
assertEquals(2, cursor.numGetMores());
cursor.next();
cursor.next();
assertEquals(3, cursor.numGetMores());
cursor.batchSize(20);
cursor.next();
cursor.next();
cursor.next();
assertEquals(4, cursor.numGetMores());
} catch (IllegalStateException e) {
assertNotNull(e); // there must be a better way to detect this.
}
}
public static void main(String[] args) throws UnknownHostException {
System.out.println("Start Testing");
MongoClient client = new MongoClient(new ServerAddress("192.168.0.14", 27017));
DB db = client.getDB("course");
DBCollection collection = db.getCollection("findTestFromJava");
collection.drop();
for (int i = 0; i < 10; i++) {
collection.insert(new BasicDBObject("x", new Random().nextInt(100)));
}
System.out.println("Find one:");
DBObject one = collection.findOne();
System.out.println("one = " + one);
System.out.println("\nFind all:");
DBCursor cursor = collection.find();
try {
while (cursor.hasNext()) {
DBObject cur = cursor.next();
System.out.println("cursor = " + cur);
}
} finally {
cursor.close();
}
System.out.println("\nFind Count:");
long count = collection.count();
System.out.println("count = " + count);
}
@Override
public DBCursor findEvents(
DBCollection collection, String aggregateIdentifier, long firstSequenceNumber) {
return collection
.find(CommitEntry.forAggregate(aggregateIdentifier, firstSequenceNumber))
.sort(new BasicDBObject(CommitEntry.SEQUENCE_NUMBER_PROPERTY, ORDER_ASC));
}
@Test(dataProvider = "ids")
public void generateSchedule(String id) throws ParseException, UnknownHostException {
DBObject query = (DBObject) JSON.parse("{_id:\"" + id + "\" }");
DBObject filter =
(DBObject)
JSON.parse(
"{"
+ "\"FpML.trade.swap.swapStream.calculationPeriodDates.effectiveDate\":1,"
+ "\"FpML.trade.swap.swapStream.calculationPeriodDates.terminationDate\":1,"
+ "\"FpML.trade.swap.swapStream.calculationPeriodDates.calculationPeriodFrequency\":1,"
+ "\"FpML.trade.swap.swapStream.calculationPeriodDates.calculationPeriodDatesAdjustments\":1,"
+ "}");
DBCursor dbCursor = fpmls.find(query, filter);
DBObject dates = dbCursor.next();
DBObject stream1 = get(dates, "FpML.trade.swap.swapStream.0.calculationPeriodDates");
List<org.jquantlib.time.Date> dates11 = generateCouponDates(stream1);
List<Date> dates12 = (List<Date>) cashflows.findOne(query).get("P");
for (Date date : dates12)
Assert.assertTrue(dates11.contains(new org.jquantlib.time.Date(date)));
DBObject stream2 = get(dates, "FpML.trade.swap.swapStream.1.calculationPeriodDates");
List<org.jquantlib.time.Date> dates21 = generateCouponDates(stream2);
List<Date> dates22 = (List<Date>) cashflows.findOne(query).get("R");
for (Date date : dates22)
Assert.assertTrue(dates21.contains(new org.jquantlib.time.Date(date)));
}
@Test(groups = "dev")
public void autoWrapTest() throws EventDeliveryException {
ctx.put(MongoSink.AUTO_WRAP, Boolean.toString(true));
ctx.put(MongoSink.DB_NAME, "test_wrap");
MongoSink sink = new MongoSink();
Configurables.configure(sink, ctx);
sink.setChannel(channel);
sink.start();
Transaction tx = channel.getTransaction();
tx.begin();
String msg =
"2012/10/26 11:23:08 [error] 7289#0: *6430831 open() \"/usr/local/nginx/html/50x.html\" failed (2: No such file or directory), client: 10.160.105.161, server: sg15.redatoms.com, request: \"POST /mojo/ajax/embed HTTP/1.0\", upstream: \"fastcgi://unix:/tmp/php-fpm.sock:\", host: \"sg15.redatoms.com\", referrer: \"http://sg15.redatoms.com/mojo/mobile/package\"";
Event e = EventBuilder.withBody(msg.getBytes());
channel.put(e);
tx.commit();
tx.close();
sink.process();
sink.stop();
DB db = mongo.getDB("test_wrap");
DBCollection collection = db.getCollection("test_log");
DBCursor cursor = collection.find(new BasicDBObject(MongoSink.DEFAULT_WRAP_FIELD, msg));
assertTrue(cursor.hasNext());
DBObject dbObject = cursor.next();
assertNotNull(dbObject);
assertEquals(dbObject.get(MongoSink.DEFAULT_WRAP_FIELD), msg);
mongo.dropDatabase("test_wrap");
}
@Test(groups = "dev")
public void sinkSingleModelTest() throws EventDeliveryException {
ctx.put(MongoSink.MODEL, MongoSink.CollectionModel.single.name());
MongoSink sink = new MongoSink();
Configurables.configure(sink, ctx);
sink.setChannel(channel);
sink.start();
Transaction tx = channel.getTransaction();
tx.begin();
JSONObject msg = new JSONObject();
msg.put("name", "test");
msg.put("age", 11);
msg.put("birthday", new Date().getTime());
Event e = EventBuilder.withBody(msg.toJSONString().getBytes());
channel.put(e);
tx.commit();
tx.close();
sink.process();
sink.stop();
DB db = mongo.getDB("test_events");
DBCollection collection = db.getCollection("test_log");
DBCursor cursor = collection.find(new BasicDBObject(msg));
assertTrue(cursor.hasNext());
DBObject dbObject = cursor.next();
assertNotNull(dbObject);
assertEquals(dbObject.get("name"), msg.get("name"));
assertEquals(dbObject.get("age"), msg.get("age"));
assertEquals(dbObject.get("birthday"), msg.get("birthday"));
}
private void customRoomLogin(ISFSEvent event) throws SFSLoginException {
trace("Game Login by session");
DBCollection users = AuthorizeExtension.users;
BasicDBObject query = new BasicDBObject();
query.put("session", generateSession);
DBCursor cursor = users.find(query);
if (!cursor.hasNext()) {
trace("Game Login User not found!", generateSession);
SFSErrorData data = new SFSErrorData(SFSErrorCode.LOGIN_BAD_PASSWORD);
data.addParameter(userName);
throw new SFSLoginException("Login failed for user: "******"Game Login User logged in!", generateSession);
document = cursor.next();
ISFSObject outData = (ISFSObject) event.getParameter(SFSEventParam.LOGIN_OUT_DATA);
outData.putUtfString(SFSConstants.NEW_LOGIN_NAME, document.get("nickname").toString());
Boolean isGuest = (Boolean) document.get("is_guest");
if (isGuest == null) {
isRegistered = true;
} else {
isRegistered = false;
}
}
}
private void handleUser(ISFSEvent event) {
trace("Registered user logged in", userName);
DBCollection users = AuthorizeExtension.users;
BasicDBObject query = new BasicDBObject();
query.put("email", userName);
DBCursor cursor = users.find(query);
if (!cursor.hasNext()) {
trace("user not found");
return;
}
document = cursor.next();
String password_digest = (String) document.get("password_digest");
if (!getApi().checkSecurePassword(session, password_digest, cryptedPass)) {
trace("password wrong");
return;
}
document.put("session", generateSession);
users.update(query, document);
isRegistered = true;
}
@Override
public String Json(String nombreDB, int clienteId) throws UnknownHostException, JSONException {
// TODO Auto-generated method stub
MongoClient mongoClient = new MongoClient("localhost", 27017);
DB base = mongoClient.getDB(nombreDB);
DBCollection collection = base.getCollection("Json");
BasicDBObject query = new BasicDBObject();
query.put("id", clienteId);
DBCursor cursor = collection.find(query);
if (cursor.size() == 0) {
// System.out.println("********************\n");
// System.out.println("No existe el cliente, no se puede ingresar json");
// System.out.println("********************\n");
return "No existe el cliente, no se puede ingresar json";
}
// Existe el cliente
DBObject objeto = (DBObject) cursor.next();
DBObject json = (DBObject) objeto.get("json");
// DBObject j = JSON.parse(json.toString());
JSONObject aj = new JSONObject(json.toString());
return aj.toString();
}
private String selectBooks(
String schema, String collection, String title, String author, String isbn)
throws UnknownHostException {
System.out.println(schema);
System.out.println(collection);
System.out.println(title);
System.out.println(author);
List<String> l = new ArrayList<String>();
MongoDBConnectionManager mgr = MongoDBConnectionManager.getInstance();
Mongo mongo = mgr.getMongo();
DB db = mongo.getDB(schema);
try {
DBCollection c = db.getCollection(collection);
BasicDBObject titleQuery = new BasicDBObject();
titleQuery.put("title", new BasicDBObject("$regex", title));
BasicDBObject authorQuery = new BasicDBObject();
authorQuery.put("author", new BasicDBObject("$regex", author));
BasicDBList or = new BasicDBList();
or.add(titleQuery);
or.add(titleQuery);
DBObject query = new BasicDBObject("$and", or);
DBCursor cursor = c.find(titleQuery);
while (cursor.hasNext()) l.add(cursor.next().toString());
} catch (Exception e) {
System.out.println(e.getMessage());
}
System.out.println(l);
if (l.size() > 0) return l.toString();
else return null;
}
private String selectBooks(String collectionType, String type, String text, String schema)
throws UnknownHostException {
System.out.println(type);
System.out.println(schema);
List<String> l = new ArrayList<String>();
MongoDBConnectionManager mgr = MongoDBConnectionManager.getInstance();
Mongo mongo = mgr.getMongo();
DB db = mongo.getDB(schema);
// collectionType = "view"
try {
DBCollection collection = db.getCollection(collectionType);
BasicDBObject searchQuery = new BasicDBObject();
BasicDBObject regexQuery = new BasicDBObject();
// regexQuery.put("title", new BasicDBObject("$regex", "^.*mi.*$").append("$options", "i"));
regexQuery.put(type, new BasicDBObject("$regex", text).append("$options", "i"));
DBCursor cursor = collection.find(regexQuery);
while (cursor.hasNext()) l.add(cursor.next().toString());
} catch (Exception e) {
System.out.println(e.getMessage());
}
System.out.println(l);
if (l.size() > 0) return l.toString();
return "error";
}
public List<String> getActiveUsersFilterBy(
String user, boolean withUsers, boolean withPublic, boolean isAdmin) {
ArrayList<String> users = new ArrayList<String>();
DBCollection coll = db().getCollection(M_TOKENS);
BasicDBObject query = new BasicDBObject();
query.put(
"validity",
new BasicDBObject(
"$gt",
System.currentTimeMillis()
- getValidity())); // check token not updated since 10sec + status interval (15 sec)
if (isAdmin) {
if (withPublic && !withUsers) {
query.put("isDemoUser", true);
} else if (!withPublic && withUsers) {
query.put("isDemoUser", false);
}
} else {
query.put("isDemoUser", user.startsWith(ANONIM_USER));
}
DBCursor cursor = coll.find(query);
while (cursor.hasNext()) {
DBObject doc = cursor.next();
String target = doc.get("user").toString();
if (!user.equals(target)) users.add(target);
}
return users;
}
public static void main(String[] args) throws UnknownHostException {
MongoClient client = new MongoClient();
DB db = client.getDB("course");
DBCollection collection = db.getCollection("findCriteriaTest");
collection.drop();
for (int i = 0; i < 10; i++) {
collection.insert(
new BasicDBObject("x", new Random().nextInt(2)).append("y", new Random().nextInt(100)));
}
QueryBuilder builder = QueryBuilder.start("x").is(0).and("y").greaterThan(10).lessThan(90);
// DBObject query = new BasicDBObject("x", 0).append("y", new BasicDBObject("$gt",
// 10).append("$lt", 90));
System.out.println("\nCount:");
long count = collection.count(builder.get());
System.out.println(count);
System.out.println("\nFind all:");
DBCursor cursor = collection.find(builder.get());
try {
while (cursor.hasNext()) {
DBObject cur = cursor.next();
System.out.println(cur);
}
} finally {
cursor.close();
}
}
/**
* Given the _id of a JSFile, return the file.
*
* @param id _id of the file to find
* @return The file, if found, otherwise null
*/
JSFile getJSFile(String id) {
if (id == null) return null;
DBCollection f = getDB().getCollection("_files");
return (JSFile) (f.find(new ObjectId(id)));
}
@Test(groups = {"basic"})
public void testCount() {
try {
DBCollection c = _db.getCollection("test");
c.drop();
assertEquals(c.find().count(), 0);
BasicDBObject obj = new BasicDBObject();
obj.put("x", "foo");
c.insert(obj);
assertEquals(c.find().count(), 1);
} catch (MongoException e) {
assertTrue(false);
}
}
public boolean hasUserWithToken(String user, String token) {
DBCollection coll = db().getCollection(M_TOKENS);
BasicDBObject query = new BasicDBObject();
query.put("user", user);
query.put("token", token);
DBCursor cursor = coll.find(query);
return (cursor.hasNext());
}
@Test(expectedExceptions = NoSuchElementException.class)
public void testShouldThrowNoSuchElementException() {
DBCollection c = _db.getCollection("emptyCollection");
DBCursor cursor = c.find();
cursor.next();
}
public static void main(String[] args) throws UnknownHostException {
MongoClient client = new MongoClient();
DB database = client.getDB("school");
DBCollection collection = database.getCollection("students");
/*
Hint/spoiler: With the new schema, this problem is a lot harder
and that is sort of the point. One way is to find the lowest
homework in code and then update the scores array with the low
homework pruned. If you are struggling with the Node.js side of
this, look at the .slice() operator, which can remove an element
from an array in-place.
*/
DBCursor cursor = collection.find();
try {
while (cursor.hasNext()) {
BasicDBObject student = (BasicDBObject) cursor.next();
int studentId = student.getInt("_id");
String name = student.getString("name");
BasicDBList scores = (BasicDBList) student.get("scores");
System.out.printf("_id[%d], name[%s], scores%s %n", studentId, name, scores);
DBObject scoreToRemove = null;
double minScoreValue = 100.0;
for (Object obj : scores) {
BasicDBObject score = (BasicDBObject) obj;
String type = score.getString("type");
if (!"homework".equals(type)) {
continue;
}
double curScoreValue = score.getDouble("score");
System.out.printf("type[%s], current score value[%f] %n", type, curScoreValue);
if (curScoreValue < minScoreValue) {
scoreToRemove = score;
minScoreValue = curScoreValue;
}
}
System.out.printf("score to remove[%s] %n", scoreToRemove);
if (scoreToRemove != null) {
scores.remove(scoreToRemove);
BasicDBObject query = new BasicDBObject("_id", studentId);
BasicDBObject scoresUpdate =
new BasicDBObject("$set", new BasicDBObject("scores", scores));
WriteResult result = collection.update(query, scoresUpdate);
System.out.printf("update count[%d] %n", result.getN());
}
}
} finally {
cursor.close();
}
}
@Test
public void testRenameAndDrop() throws MongoException {
String namea = "testRenameA";
String nameb = "testRenameB";
DBCollection a = getDatabase().getCollection(namea);
DBCollection b = getDatabase().getCollection(nameb);
a.drop();
b.drop();
assertEquals(0, a.find().count());
assertEquals(0, b.find().count());
a.save(new BasicDBObject("x", 1));
b.save(new BasicDBObject("x", 1));
assertEquals(1, a.find().count());
assertEquals(1, b.find().count());
DBCollection b2 = a.rename(nameb, true);
assertEquals(0, a.find().count());
assertEquals(1, b.find().count());
assertEquals(1, b2.find().count());
assertEquals(b.getName(), b2.getName());
}
public List<DBObject> getSince(String login, Long since) {
Date minDate = new Date(since);
DBCursor notifications =
collection.find(
QueryBuilder.start("date").greaterThan(minDate).and("login").notEquals(login).get());
return notifications.toArray();
}
public List<Todo> findAll() {
List<Todo> todos = new ArrayList<>();
DBCursor dbObjects = collection.find();
while (dbObjects.hasNext()) {
DBObject dbObject = dbObjects.next();
todos.add(new Todo((BasicDBObject) dbObject));
}
return todos;
}
private void removeUser(String user) {
DBCollection coll = db().getCollection(M_TOKENS);
BasicDBObject query = new BasicDBObject();
query.put("user", user);
DBCursor cursor = coll.find(query);
while (cursor.hasNext()) {
DBObject doc = cursor.next();
coll.remove(doc);
}
}
public boolean ExisteCliente(String nombreDB, int clienteId) throws UnknownHostException {
MongoClient mongoClient = new MongoClient("localhost", 27017);
DB base = mongoClient.getDB(nombreDB);
DBCollection collection = base.getCollection("Json");
BasicDBObject query = new BasicDBObject();
query.put("id", clienteId);
DBCursor cursor = collection.find(query);
return cursor.size() > 0;
}
@Override
public DBCursor findEvents(DBCollection collection, MongoCriteria criteria) {
DBObject filter = criteria == null ? null : criteria.asMongoObject();
DBObject sort =
BasicDBObjectBuilder.start()
.add(CommitEntry.TIME_STAMP_PROPERTY, ORDER_ASC)
.add(CommitEntry.SEQUENCE_NUMBER_PROPERTY, ORDER_ASC)
.get();
return collection.find(filter).sort(sort);
}
@Test
public void testBatchWithLimit() {
DBCollection c = _db.getCollection("batchWithLimit1");
c.drop();
for (int i = 0; i < 100; i++) c.save(new BasicDBObject("x", i));
assertEquals(50, c.find().limit(50).itcount());
assertEquals(50, c.find().batchSize(5).limit(50).itcount());
}
@Test
public void testHasFinalizer() throws UnknownHostException {
DBCollection c = _db.getCollection("HasFinalizerTest");
c.drop();
for (int i = 0; i < 1000; i++) c.save(new BasicDBObject("_id", i), WriteConcern.SAFE);
// finalizer is on by default so after calling hasNext should report that it has one
DBCursor cursor = c.find();
assertFalse(cursor.hasFinalizer());
cursor.hasNext();
assertTrue(cursor.hasFinalizer());
cursor.close();
// no finalizer if there is no cursor, as there should not be for a query with only one result
cursor = c.find(new BasicDBObject("_id", 1));
cursor.hasNext();
assertFalse(cursor.hasFinalizer());
cursor.close();
// no finalizer if there is no cursor, as there should not be for a query with negative batch
// size
cursor = c.find();
cursor.batchSize(-1);
cursor.hasNext();
assertFalse(cursor.hasFinalizer());
cursor.close();
// finally, no finalizer if disabled in mongo options
MongoOptions mongoOptions = new MongoOptions();
mongoOptions.cursorFinalizerEnabled = false;
Mongo m = new Mongo("127.0.0.1", mongoOptions);
try {
c = m.getDB(cleanupDB).getCollection("HasFinalizerTest");
cursor = c.find();
cursor.hasNext();
assertFalse(cursor.hasFinalizer());
cursor.close();
} finally {
m.close();
}
}