예제 #1
0
  @Test
  public void testStore() {
    HasExpiryField hasExpiryField = new HasExpiryField();
    hasExpiryField.setOfferIs("Good");
    Calendar c = Calendar.getInstance();
    hasExpiryField.setOfferExpiresAt(c.getTime());
    ds.getMapper().addMappedClass(HasExpiryField.class);
    ds.ensureIndexes();
    ds.save(hasExpiryField);

    DB db = ds.getDB();
    DBCollection dbCollection = db.getCollection("HasExpiryField");
    List<DBObject> indexes = dbCollection.getIndexInfo();

    Assert.assertNotNull(indexes);
    Assert.assertEquals(2, indexes.size());
    DBObject index = null;
    for (DBObject candidateIndex : indexes) {
      if (candidateIndex.containsField("expireAfterSeconds")) {
        index = candidateIndex;
      }
    }
    Assert.assertNotNull(index);
    Assert.assertTrue(index.containsField("expireAfterSeconds"));
    Assert.assertEquals(60, index.get("expireAfterSeconds"));
  }
 /*
  * Extract "_id" from "o" if it fails try to extract from "o2"
  */
 private String getObjectIdFromOplogEntry(DBObject entry) {
   if (entry.containsField(MongoDBRiver.OPLOG_OBJECT)) {
     DBObject object = (DBObject) entry.get(MongoDBRiver.OPLOG_OBJECT);
     if (object.containsField(MongoDBRiver.MONGODB_ID_FIELD)) {
       return object.get(MongoDBRiver.MONGODB_ID_FIELD).toString();
     }
   }
   if (entry.containsField(MongoDBRiver.OPLOG_UPDATE)) {
     DBObject object = (DBObject) entry.get(MongoDBRiver.OPLOG_UPDATE);
     if (object.containsField(MongoDBRiver.MONGODB_ID_FIELD)) {
       return object.get(MongoDBRiver.MONGODB_ID_FIELD).toString();
     }
   }
   return null;
 }
예제 #3
0
  @Test
  public void integrationTestInsertCall() throws Exception {

    missedCallsDAO = new MissedCallsDAO(Resources.getDatabaseActivity());

    DBObject testCall = new BasicDBObject("who", 9581300084L);
    try {
      assertTrue(missedCallsDAO.insertCall(testCall));
      assertTrue(testCall.containsField("arrival"));
      assertEquals("Pending", testCall.get("state"));
      assertTrue(testCall.containsField("_id"));
    } finally {
      deleteCall(testCall);
    }
  }
예제 #4
0
 public void ensureCaps() {
   for (MappedClass mc : mapr.getMappedClasses())
     if (mc.getEntityAnnotation() != null && mc.getEntityAnnotation().cap().value() > 0) {
       CappedAt cap = mc.getEntityAnnotation().cap();
       String collName = mapr.getCollectionName(mc.getClazz());
       BasicDBObjectBuilder dbCapOpts = BasicDBObjectBuilder.start("capped", true);
       if (cap.value() > 0) dbCapOpts.add("size", cap.value());
       if (cap.count() > 0) dbCapOpts.add("max", cap.count());
       DB db = getDB();
       if (db.getCollectionNames().contains(collName)) {
         DBObject dbResult = db.command(BasicDBObjectBuilder.start("collstats", collName).get());
         if (dbResult.containsField("capped")) {
           // TODO: check the cap options.
           log.warning("DBCollection already exists is cap'd already; doing nothing. " + dbResult);
         } else {
           log.warning(
               "DBCollection already exists with same name("
                   + collName
                   + ") and is not cap'd; not creating cap'd version!");
         }
       } else {
         getDB().createCollection(collName, dbCapOpts.get());
         log.debug("Created cap'd DBCollection (" + collName + ") with opts " + dbCapOpts);
       }
     }
 }
예제 #5
0
 private void fixThumbnailImages() {
   DBObject query = new BasicDBObject("card_image_url", new BasicDBObject("$exists", false));
   for (Iterator<DBObject> it = mPhotoCollection.find(query); it.hasNext(); ) {
     DBObject photo = it.next();
     if (!photo.containsField("portal_image_url")) {
       System.err.println("No portal_image_url in " + photo);
       continue;
     }
     String portal_image_url = photo.get("portal_image_url").toString();
     if (!portal_image_url.matches("^https?://.*")) {
       portal_image_url = Config.ALBUM_ROOT + portal_image_url;
     }
     try {
       URL url = new URL(portal_image_url);
       System.err.println("Missing thumbnail images for " + url);
       BufferedImage[] images = ImageUtil.convertImage(url);
       if (images != null) {
         DBObject updates = new BasicDBObject();
         saveThumbnailImages(updates, images, url.getPath().replace(".", "_") + ".png");
         mPhotoCollection.update(photo, new BasicDBObject("$set", updates));
       } else {
         System.err.println(url + " corrupted");
       }
     } catch (MalformedURLException e) {
       System.err.println("Unknown image URL" + portal_image_url);
       continue;
     }
   }
 }
예제 #6
0
 private void deleteCall(DBObject call) throws UnknownHostException {
   if (call.containsField("_id")) {
     Resources.getDatabaseActivity()
         .getCollection("MissedCalls")
         .remove(new BasicDBObject("_id", call.get("_id")));
   }
 }
  @Override
  public Node getModel(ObjectId id) {
    DBObject dbNode = getDatabase().findOne("nodes", new BasicDBObject("_id", id));

    if (dbNode == null) {
      return null;
    }

    Node node = new Node((ObjectId) dbNode.get("_id"), (Date) dbNode.get("created_at"));
    node.setUpdated_at((Date) dbNode.get("updated_at"));
    node.setName((String) dbNode.get("name"));
    node.setPrivateAddress((String) dbNode.get("privateAddress"));
    node.setRam(Integer.parseInt((String) dbNode.get("ram")));

    if (dbNode.containsField("publicaddresses")) {
      BasicDBList publicAddressList = (BasicDBList) dbNode.get("publicaddresses");

      for (Object objPublicAddress : publicAddressList) {
        DBObject dbPublicAddress = (DBObject) objPublicAddress;

        NodePublicAddress nodePublicAddress =
            new NodePublicAddress(
                (ObjectId) dbPublicAddress.get("_id"), (Date) dbPublicAddress.get("created_at"));
        nodePublicAddress.setUpdated_at((Date) dbPublicAddress.get("updated_at"));
        nodePublicAddress.setPublicAddress((String) dbPublicAddress.get("publicAddress"));
        nodePublicAddress.setNode(node);
        node.getPublicAddresses().put(nodePublicAddress.getId(), nodePublicAddress);
      }
    }

    return node;
  }
예제 #8
0
 @PostPersist
 void postPersistWithParam(final DBObject dbObj) {
   postPersistWithParam = true;
   if (!dbObj.containsField(Mapper.ID_KEY)) {
     throw new RuntimeException("missing " + Mapper.ID_KEY);
   }
 }
  protected void writeInternal(Object obj, final DBObject dbo, MongoPersistentEntity<?> entity) {

    if (obj == null) {
      return;
    }

    if (null == entity) {
      throw new MappingException(
          "No mapping metadata found for entity of type " + obj.getClass().getName());
    }

    final PersistentPropertyAccessor accessor = entity.getPropertyAccessor(obj);
    final MongoPersistentProperty idProperty = entity.getIdProperty();

    if (!dbo.containsField("_id") && null != idProperty) {

      try {
        Object id = accessor.getProperty(idProperty);
        dbo.put("_id", idMapper.convertId(id));
      } catch (ConversionException ignored) {
      }
    }

    // Write the properties
    entity.doWithProperties(
        new PropertyHandler<MongoPersistentProperty>() {
          public void doWithPersistentProperty(MongoPersistentProperty prop) {

            if (prop.equals(idProperty) || !prop.isWritable()) {
              return;
            }

            Object propertyObj = accessor.getProperty(prop);

            if (null != propertyObj) {

              if (!conversions.isSimpleType(propertyObj.getClass())) {
                writePropertyInternal(propertyObj, dbo, prop);
              } else {
                writeSimpleInternal(propertyObj, dbo, prop);
              }
            }
          }
        });

    entity.doWithAssociations(
        new AssociationHandler<MongoPersistentProperty>() {

          public void doWithAssociation(Association<MongoPersistentProperty> association) {

            MongoPersistentProperty inverseProp = association.getInverse();
            Object propertyObj = accessor.getProperty(inverseProp);

            if (null != propertyObj) {
              writePropertyInternal(propertyObj, dbo, inverseProp);
            }
          }
        });
  }
예제 #10
0
 private String addInsertToStream(
     final Timestamp<?> currentTimestamp, final DBObject data, final String collection)
     throws InterruptedException {
   totalDocuments.incrementAndGet();
   addToStream(Operation.INSERT, currentTimestamp, data, collection);
   return data.containsField(MongoDBRiver.MONGODB_ID_FIELD)
       ? data.get(MongoDBRiver.MONGODB_ID_FIELD).toString()
       : null;
 }
예제 #11
0
  @Test
  public void testInsertCall() throws Exception {
    DBObject callObj = new BasicDBObject();

    assertTrue(missedCallsDAO.insertCall(callObj));
    assertTrue(callObj.containsField("arrival"));
    assertEquals("Pending", callObj.get("state"));
    verify(missedCalls, times(1)).insert(any(DBObject.class));
  }
예제 #12
0
 private void processAdminCommandOplogEntry(
     final DBObject entry, final Timestamp<?> startTimestamp) throws InterruptedException {
   if (logger.isTraceEnabled()) {
     logger.trace("processAdminCommandOplogEntry - [{}]", entry);
   }
   DBObject object = (DBObject) entry.get(MongoDBRiver.OPLOG_OBJECT);
   if (definition.isImportAllCollections()) {
     if (object.containsField(MongoDBRiver.OPLOG_RENAME_COLLECTION_COMMAND_OPERATION)
         && object.containsField(MongoDBRiver.OPLOG_TO)) {
       String to = object.get(MongoDBRiver.OPLOG_TO).toString();
       if (to.startsWith(definition.getMongoDb())) {
         String newCollection = getCollectionFromNamespace(to);
         DBCollection coll = slurpedDb.getCollection(newCollection);
         doInitialImport(coll);
       }
     }
   }
 }
예제 #13
0
    @Override
    public Object createObject(byte[] data, int offset) {
      DBObject dbo = new LazyBsonByte(data, offset, this);

      Iterator it = dbo.keySet().iterator();
      if (it.hasNext() && it.next().equals("$ref") && dbo.containsField("$id")) {
        return new DBRef(db, dbo);
      }
      return dbo;
    }
예제 #14
0
  @Override
  public Node byNodeId(String nodeId) throws NodeNotFoundException {
    DBObject query = new BasicDBObject("node_id", nodeId);
    DBObject o = findOne(NodeImpl.class, query);

    if (o == null || !o.containsField("node_id")) {
      throw new NodeNotFoundException("Unable to find node " + nodeId);
    }

    return new NodeImpl((ObjectId) o.get("_id"), o.toMap());
  }
  /** @see DATAMONGO-404 */
  @Test
  public void rendersNestedDbRefCorrectly() {

    Update update = new Update().pull("nested.dbRefAnnotatedList.id", "2");
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(Wrapper.class));

    DBObject pullClause = getAsDBObject(mappedObject, "$pull");
    assertThat(pullClause.containsField("mapped.dbRefAnnotatedList"), is(true));
  }
  public String getAccountConnected(String msisdn, DB userDB) {
    DBCollection collection = userDB.getCollection(HikeConstants.MONGO_USERS_COLLECTION);
    BasicDBObject query = new BasicDBObject();
    query.put(HikeConstants.MSISDN, msisdn);
    DBObject result = collection.findOne(query, new BasicDBObject().append("accounts", 1));
    if ((result == null) || !result.containsField("accounts")) {
      return null;
    }

    return result.get("accounts").toString();
  }
예제 #17
0
 private boolean filterMatch(DBObject filter, DBObject object) {
   for (String key : filter.keySet()) {
     if (!object.containsField(key)) {
       return false;
     }
     if (!filter.get(key).equals(object.get(key))) {
       return false;
     }
   }
   return true;
 }
  /** @see DATAMONGO-862 */
  @Test
  public void rendersUpdateAndPreservesKeyForPathsNotPointingToProperty() {

    Update update = new Update().set("listOfInterface.$.value", "expected-value");
    DBObject mappedObject =
        mapper.getMappedObject(
            update.getUpdateObject(), context.getPersistentEntity(ParentClass.class));

    DBObject setClause = getAsDBObject(mappedObject, "$set");
    assertThat(setClause.containsField("listOfInterface.$.value"), is(true));
  }
  public String getDetailsFromMsisdn(String msisdn, String field) {
    DBCollection collection = userDB.getCollection(HikeConstants.MONGO_USERS_COLLECTION);
    BasicDBObject query = new BasicDBObject();
    query.put(HikeConstants.MSISDN, msisdn);
    DBObject result = collection.findOne(query, new BasicDBObject().append(field, 1));
    if ((result == null) || !result.containsField(field)) {
      return null;
    }

    return result.get(field).toString();
  }
예제 #20
0
  /**
   * @param user
   * @return gender if exists, else UNKNOWN
   */
  public static String getGender(DBObject user) {
    if (user != null) {
      if (!user.containsField(User.ATTR_GENDER) || user.get(User.ATTR_GENDER) == null) {
        return Gender.UNKNOWN.getValue();
      }

      return (String) user.get(User.ATTR_GENDER);
    }

    return null;
  }
 /**
  * Find and mask property values.
  *
  * <p>Properties will be searched for deeply.
  *
  * @param obj the object to modify
  */
 public static DBObject maskValues(DBObject dbObject) {
   if (dbObject instanceof BasicDBList) {
     BasicDBList objListOrig = (BasicDBList) dbObject;
     // Copy entries to a new list
     BasicDBList newObjList = new BasicDBList();
     for (Object origListObjT : objListOrig) {
       DBObject origListObj = (DBObject) origListObjT;
       // Mask any values
       DBObject newListObj = maskValues(origListObj);
       newObjList.add(newListObj);
     }
     // Done
     return newObjList;
   } else if (dbObject.containsField(FIELD_MASK)) {
     boolean mask = Boolean.parseBoolean((String) dbObject.get(FIELD_MASK));
     if (mask) {
       DBObject newObj = copyDBObject(dbObject);
       // We have a copy to play with
       newObj.put(FIELD_DEFAULT, MASK);
       if (dbObject.get(FIELD_VALUE) != null) {
         newObj.put(FIELD_VALUE, MASK);
       }
       return newObj;
     } else {
       return dbObject;
     }
   } else if (dbObject.containsField(FIELD_PROPERTIES)) {
     // There are properties
     BasicDBList propsObj = (BasicDBList) dbObject.get(FIELD_PROPERTIES);
     BasicDBList newPropsObj = (BasicDBList) maskValues(propsObj);
     // Copy
     DBObject newObj = copyDBObject(dbObject);
     newObj.put(FIELD_PROPERTIES, newPropsObj);
     // Done
     return newObj;
   } else {
     // Not a list and does not contain the mask field
     return dbObject;
   }
 }
  public String getBlockedUserList(String msisdnBlocker, DB userDB) {
    DBCollection collection = userDB.getCollection(HikeConstants.COMMON_BLOCKLIST);
    BasicDBObject query = new BasicDBObject();
    query.put(HikeConstants.MSISDN, msisdnBlocker);
    DBObject result = collection.findOne(query);
    if ((result == null)
        || !result.containsField("blocklist")
        || result.get("blocklist").toString().equals("[ ]")) {
      return null;
    }

    return result.get("blocklist").toString();
  }
  @Test
  public void writesTypeDiscriminatorIntoRootObject() {

    Person person = new Person();
    person.birthDate = new LocalDate();

    DBObject result = new BasicDBObject();
    converter.write(person, result);

    assertThat(result.containsField(MappingMongoConverter.CUSTOM_TYPE_KEY), is(true));
    assertThat(
        result.get(MappingMongoConverter.CUSTOM_TYPE_KEY).toString(), is(Person.class.getName()));
  }
  @Override
  public List<Favorite> addToFavorites(String email, List<Favorite> localFavorites)
      throws UserNotFound {
    if (email == null) {
      throw new IllegalArgumentException("Email cannot be null");
    }
    DBCollection col = db.getCollection(MongoDBConstants.COLLECTION_USERS);
    // Search user by email
    DBObject userDb = col.findOne(new BasicDBObject(MongoDBConstants.USER_PROP_EMAIL, email));
    if (userDb == null) {
      throw new UserNotFound("Unable to find user with email '" + email + "'");
    }

    DBObject favoritesDb = (DBObject) userDb.get(MongoDBConstants.USER_PROP_FAVORITES);
    if (favoritesDb == null) {
      favoritesDb = new BasicDBObject();
    }

    if (localFavorites != null) {
      for (Favorite localFavorite : localFavorites) {
        DBObject favoriteItemsDb = (DBObject) favoritesDb.get(localFavorite.getStationId());
        long lastMessageIdDb = -1;
        if (favoriteItemsDb == null) {
          favoriteItemsDb = new BasicDBObject();
        } else {
          if (favoriteItemsDb.containsField(MongoDBConstants.USER_PROP_FAVORITE_LASTMESSAGEID)) {
            lastMessageIdDb =
                (Long) favoriteItemsDb.get(MongoDBConstants.USER_PROP_FAVORITE_LASTMESSAGEID);
          }
        }

        favoriteItemsDb.put(
            MongoDBConstants.USER_PROP_FAVORITE_LASTMESSAGEID,
            Math.max(lastMessageIdDb, localFavorite.getLastMessageId()));
        favoritesDb.put(localFavorite.getStationId(), favoriteItemsDb);
      }
    }
    userDb.put(MongoDBConstants.USER_PROP_FAVORITES, favoritesDb);
    col.save(userDb);

    List<Favorite> returnValue = new ArrayList<Favorite>(favoritesDb.keySet().size());
    for (String stationId : favoritesDb.keySet()) {
      Favorite favorite = new Favorite();
      favorite.setStationId(stationId);
      DBObject favoriteItemDb = (DBObject) favoritesDb.get(stationId);
      favorite.setLastMessageId(
          (Long) favoriteItemDb.get(MongoDBConstants.USER_PROP_FAVORITE_LASTMESSAGEID));
      returnValue.add(favorite);
    }
    return returnValue;
  }
예제 #25
0
  public DBObject findByPermalink(String permalink) {
    DBObject post = postsCollection.findOne(new BasicDBObject("permalink", permalink));

    // fix up if a post has no likes
    if (post != null) {
      List<DBObject> comments = (List<DBObject>) post.get("comments");
      for (DBObject comment : comments) {
        if (!comment.containsField("num_likes")) {
          comment.put("num_likes", 0);
        }
      }
    }
    return post;
  }
예제 #26
0
  private Filter buildExpressionFilter(final List<String> path, Object expression) {
    if (OR.equals(path.get(0))) {
      @SuppressWarnings("unchecked")
      Collection<DBObject> queryList = typecast(path + " operator", expression, Collection.class);
      OrFilter orFilter = new OrFilter();
      for (DBObject query : queryList) {
        orFilter.addFilter(buildFilter(query));
      }
      return orFilter;
    } else if (AND.equals(path.get(0))) {
      Collection<DBObject> queryList = typecast(path + " operator", expression, Collection.class);
      AndFilter andFilter = new AndFilter();
      for (DBObject query : queryList) {
        andFilter.addFilter(buildFilter(query));
      }
      return andFilter;
    } else if (WHERE.equals(path.get(0))) {
      return new WhereFilter((String) expression);
    } else if (expression instanceof DBObject || expression instanceof Map) {
      DBObject ref =
          expression instanceof DBObject
              ? (DBObject) expression
              : new BasicDBObject((Map) expression);

      if (ref.containsField(NOT)) {
        return new NotFilter(buildExpressionFilter(path, ref.get(NOT)));
      } else {

        AndFilter andFilter = new AndFilter();
        int matchCount = 0;
        for (FilterFactory filterFactory : filterFactories) {
          if (filterFactory.matchesCommand(ref)) {
            matchCount++;
            andFilter.addFilter(filterFactory.createFilter(path, ref));
          }
        }
        if (matchCount == 0) {
          return simpleFilter(path, expression);
        }
        if (matchCount > 2) {
          throw new FongoException("Invalid expression for key " + path + ": " + expression);
        }
        return andFilter;
      }
    } else if (expression instanceof Pattern) {
      return createPatternFilter(path, (Pattern) expression);
    } else {
      return simpleFilter(path, expression);
    }
  }
예제 #27
0
 /**
  * @param source
  * @param target
  */
 public static void copyUser(DBObject source, DBObject target) {
   for (String property :
       new String[] {
         "email", "name", "gender", "yearOfBirth", "state", "settings", EntityUtils.ID
       }) {
     if (source.containsField(property)) {
       if (Map.class.isInstance(source.get(property))) {
         target.put(property, new BasicDBObject(Map.class.cast(source.get(property))));
       } else {
         target.put(property, source.get(property));
       }
     }
   }
 }
예제 #28
0
  @Test
  public void integrationTestFetchNextPendingCall() throws Exception {

    missedCallsDAO = new MissedCallsDAO(Resources.getDatabaseActivity());

    DBObject testCallFirst = new BasicDBObject("who", 9581300084L);
    DBObject testCallSecond = new BasicDBObject("who", 9581300084L);

    try {
      assertTrue(missedCallsDAO.insertCall(testCallFirst));
      Thread.sleep(1000);
      assertTrue(missedCallsDAO.insertCall(testCallSecond));

      Date tsFirst = (Date) testCallFirst.get("arrival");
      Date tsSecond = (Date) testCallSecond.get("arrival");
      assertTrue(tsFirst.before(tsSecond));

      DBObject fetchedCallFirst = missedCallsDAO.fetchNextPendingCall();
      assertNotNull(fetchedCallFirst);
      assertTrue(fetchedCallFirst.containsField("who"));
      assertEquals("Processing", fetchedCallFirst.get("state"));
      assertEquals(testCallSecond.get("_id"), fetchedCallFirst.get("_id"));

      DBObject fetchedCallSecond = missedCallsDAO.fetchNextPendingCall();
      assertNotNull(fetchedCallSecond);
      assertTrue(fetchedCallSecond.containsField("who"));
      assertEquals("Processing", fetchedCallSecond.get("state"));
      assertEquals(testCallFirst.get("_id"), fetchedCallSecond.get("_id"));

      tsFirst = (Date) fetchedCallFirst.get("arrival");
      tsSecond = (Date) fetchedCallSecond.get("arrival");
      assertTrue(tsFirst.after(tsSecond));
    } finally {
      deleteCall(testCallFirst);
      deleteCall(testCallSecond);
    }
  }
  @Override
  public Server getModel(ObjectId id) {
    DBObject dbServer = getDatabase().findOne("servers", new BasicDBObject("_id", id));

    if (dbServer == null) {
      return null;
    }

    Server server = new Server((ObjectId) dbServer.get("_id"), (Date) dbServer.get("created_at"));
    server.setUpdated_at((Date) dbServer.get("updated_at"));
    server.setNetwork(
        getDatabase()
            .getNetworkRepository()
            .getModel(new ObjectId((String) dbServer.get("network_id"))));
    String node = (String) dbServer.get("node_id");
    if (node != null) {
      server.setNode(getDatabase().getNodeRepository().getModel(new ObjectId(node)));
    }
    server.setServerType(
        getDatabase()
            .getServerTypeRepository()
            .getModel(new ObjectId((String) dbServer.get("server_type_id"))));
    server.setContainerId((String) dbServer.get("container"));
    server.setPort((int) dbServer.get("port"));

    BasicDBObject dbPlayers = (BasicDBObject) dbServer.get("players");
    for (String name : dbPlayers.keySet()) {
      server.getPlayers().put(name, (UUID) dbPlayers.get(name));
    }

    if (dbServer.containsField("metaData")) {
      BasicDBList metaDataList = (BasicDBList) dbServer.get("metaData");
      for (Object metaDataObj : metaDataList) {
        DBObject dbMetaData = (DBObject) metaDataObj;

        ServerMetaData metaData =
            new ServerMetaData(
                (ObjectId) dbMetaData.get("_id"), (Date) dbMetaData.get("created_at"));
        metaData.setUpdated_at((Date) dbMetaData.get("updated_at"));
        metaData.setKey((String) dbMetaData.get("key"));
        metaData.setValue((String) dbMetaData.get("value"));

        server.getMetaData().put(metaData.getKey(), metaData);
      }
    }

    server.setNumber((int) dbServer.get("number"));
    return server;
  }
  /** @see DATAMONGO-943 */
  @Test
  public void updatePushEachAtPositionWorksCorrectlyWhenGivenPositionNull() {

    Update update =
        new Update().push("key").atPosition(null).each(Arrays.asList("Arya", "Arry", "Weasel"));

    DBObject mappedObject =
        mapper.getMappedObject(update.getUpdateObject(), context.getPersistentEntity(Object.class));

    DBObject push = getAsDBObject(mappedObject, "$push");
    DBObject key = getAsDBObject(push, "key");

    assertThat(key.containsField("$position"), is(false));
    assertThat(getAsDBObject(push, "key").containsField("$each"), is(true));
  }