Ejemplo n.º 1
0
  private void doDownload(final BsonDocument arguments, final BsonDocument assertion) {
    Throwable error = null;
    final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

    try {
      new MongoOperation<Long>() {
        @Override
        public void execute() {
          gridFSBucket.downloadToStream(
              arguments.getObjectId("id").getValue(),
              toAsyncOutputStream(outputStream),
              getCallback());
        }
      }.get();
      outputStream.close();
    } catch (Throwable e) {
      error = e;
    }

    if (assertion.containsKey("result")) {
      assertNull("Should not have thrown an exception", error);
      assertEquals(
          printHexBinary(outputStream.toByteArray()).toLowerCase(),
          assertion.getDocument("result").getString("$hex").getValue());
    } else if (assertion.containsKey("error")) {
      assertNotNull("Should have thrown an exception", error);
    }
  }
Ejemplo n.º 2
0
  public void init() {

    try {
      schedFact = new org.quartz.impl.StdSchedulerFactory();
      sched = schedFact.getScheduler();
      if (sched.isStarted() == false) sched.start();

      MongoCollection<BsonDocument> collection =
          Configuration.mongoDatabase.getCollection("Subscription", BsonDocument.class);

      Iterator<BsonDocument> subIterator = collection.find(BsonDocument.class).iterator();
      MongoQueryService queryService = new MongoQueryService();
      while (subIterator.hasNext()) {
        BsonDocument sub = subIterator.next();
        SubscriptionType subscription = new SubscriptionType(sub);
        if (subscription.getSchedule() != null && subscription.getTrigger() == null) {
          queryService.addScheduleToQuartz(subscription);
        } else if (subscription.getSchedule() == null && subscription.getTrigger() != null) {
          TriggerEngine.addTriggerSubscription(
              sub.getString("subscriptionID").getValue(), subscription);
        }
      }

    } catch (SchedulerException e) {
      Configuration.logger.log(Level.ERROR, e.toString());
    }
  }
 private void beforeFields(
     final BsonWriter bsonWriter, final EncoderContext encoderContext, final BsonDocument value) {
   if (encoderContext.isEncodingCollectibleDocument() && value.containsKey(ID_FIELD_NAME)) {
     bsonWriter.writeName(ID_FIELD_NAME);
     writeValue(bsonWriter, encoderContext, value.get(ID_FIELD_NAME));
   }
 }
Ejemplo n.º 4
0
  private void doDownloadByName(final BsonDocument arguments, final BsonDocument assertion) {
    Throwable error = null;
    final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

    try {
      final GridFSDownloadByNameOptions options = new GridFSDownloadByNameOptions();
      if (arguments.containsKey("options")) {
        int revision = arguments.getDocument("options").getInt32("revision").getValue();
        options.revision(revision);
      }

      new MongoOperation<Long>() {
        @Override
        public void execute() {
          gridFSBucket.downloadToStreamByName(
              arguments.getString("filename").getValue(),
              toAsyncOutputStream(outputStream),
              options,
              getCallback());
        }
      }.get();

      outputStream.close();
    } catch (Throwable e) {
      error = e;
    }
    if (assertion.containsKey("result")) {
      assertNull("Should not have thrown an exception", error);
      assertEquals(
          printHexBinary(outputStream.toByteArray()).toLowerCase(),
          assertion.getDocument("result").getString("$hex").getValue());
    } else if (assertion.containsKey("error")) {
      assertNotNull("Should have thrown an exception", error);
    }
  }
 private void sendStartedEvent(
     final InternalConnection connection,
     final ByteBufferBsonOutput bsonOutput,
     final CommandMessage message,
     final int documentPosition) {
   if (commandListener != null) {
     ByteBufBsonDocument byteBufBsonDocument = createOne(bsonOutput, documentPosition);
     BsonDocument commandDocument;
     if (byteBufBsonDocument.containsKey("$query")) {
       commandDocument = byteBufBsonDocument.getDocument("$query");
       commandName = commandDocument.keySet().iterator().next();
     } else {
       commandDocument = byteBufBsonDocument;
       commandName = byteBufBsonDocument.getFirstKey();
     }
     BsonDocument commandDocumentForEvent =
         (SECURITY_SENSITIVE_COMMANDS.contains(commandName))
             ? new BsonDocument()
             : commandDocument;
     sendCommandStartedEvent(
         message,
         namespace.getDatabaseName(),
         commandName,
         commandDocumentForEvent,
         connection.getDescription(),
         commandListener);
   }
 }
Ejemplo n.º 6
0
  @Before
  @Override
  public void setUp() {
    super.setUp();
    gridFSBucket = GridFSBuckets.create(database);
    filesCollection =
        Fixture.initializeCollection(new MongoNamespace(getDefaultDatabaseName(), "fs.files"))
            .withDocumentClass(BsonDocument.class);
    chunksCollection =
        Fixture.initializeCollection(new MongoNamespace(getDefaultDatabaseName(), "fs.chunks"))
            .withDocumentClass(BsonDocument.class);

    final List<BsonDocument> filesDocuments =
        processFiles(data.getArray("files", new BsonArray()), new ArrayList<BsonDocument>());
    if (!filesDocuments.isEmpty()) {
      new MongoOperation<Void>() {
        @Override
        public void execute() {
          filesCollection.insertMany(filesDocuments, getCallback());
        }
      }.get();
    }

    final List<BsonDocument> chunksDocuments =
        processChunks(data.getArray("chunks", new BsonArray()), new ArrayList<BsonDocument>());
    if (!chunksDocuments.isEmpty()) {
      new MongoOperation<Void>() {
        @Override
        public void execute() {
          chunksCollection.insertMany(chunksDocuments, getCallback());
        }
      }.get();
    }
  }
Ejemplo n.º 7
0
 private BsonDocument parseHexDocument(final BsonDocument document, final String hexDocument) {
   if (document.containsKey(hexDocument) && document.get(hexDocument).isDocument()) {
     byte[] bytes =
         DatatypeConverter.parseHexBinary(
             document.getDocument(hexDocument).getString("$hex").getValue());
     document.put(hexDocument, new BsonBinary(bytes));
   }
   return document;
 }
Ejemplo n.º 8
0
  public void putRecipeSummary(RecipeSummary recipeSummary) {
    MongoCollection<BsonDocument> collectionRecipeSummary =
        database.getCollection("recipeSummary", BsonDocument.class);
    BsonDocument bsonDocument = BsonDocument.parse(recipeSummary.toJson());
    bsonDocument.put("_id", new BsonString(recipeSummary.getRecipeId()));
    LOG.info("put bsonDocument = {}", bsonDocument.toString());

    collectionRecipeSummary.replaceOne(
        eq("_id", recipeSummary.getRecipeId()), bsonDocument, new UpdateOptions().upsert(true));
    //        collectionRecipeSummary.insertOne(bsonDocument);
  }
Ejemplo n.º 9
0
 public RecipeSummary getRecipeSummary(String recipeId) {
   MongoCollection<BsonDocument> collectionRecipeSummary =
       database.getCollection("recipeSummary", BsonDocument.class);
   BsonDocument document = collectionRecipeSummary.find(eq("_id", recipeId)).first();
   if (document != null) {
     LOG.info("get document = {}", document.toString());
     return new RecipeSummary().fromJson(document.toJson());
   } else {
     LOG.info("Null Document for recipeId={}", recipeId);
     return null;
   }
 }
 private static <T> QueryResult<T> cursorDocumentToQueryResult(
     final BsonDocument cursorDocument,
     final ServerAddress serverAddress,
     final String fieldNameContainingBatch) {
   long cursorId = ((BsonInt64) cursorDocument.get("id")).getValue();
   MongoNamespace queryResultNamespace =
       new MongoNamespace(cursorDocument.getString("ns").getValue());
   return new QueryResult<T>(
       queryResultNamespace,
       BsonDocumentWrapperHelper.<T>toList(cursorDocument, fieldNameContainingBatch),
       cursorId,
       serverAddress);
 }
Ejemplo n.º 11
0
 @Override
 public BsonDocument generateIdIfAbsentFromDocument(final BsonDocument document) {
   if (!documentHasId(document)) {
     document.put(ID_FIELD_NAME, new BsonObjectId(new ObjectId()));
   }
   return document;
 }
Ejemplo n.º 12
0
  public BsonDocument asBsonDocument() {
    CaptureUtil util = new CaptureUtil();

    BsonDocument objectEvent = super.asBsonDocument();
    // Required Fields
    objectEvent = util.putAction(objectEvent, action);

    // Optional Fields
    if (this.epcList != null && this.epcList.size() != 0) {
      objectEvent = util.putEPCList(objectEvent, epcList);
    }
    if (this.bizStep != null) {
      objectEvent = util.putBizStep(objectEvent, bizStep);
    }
    if (this.disposition != null) {
      objectEvent = util.putDisposition(objectEvent, disposition);
    }
    if (this.readPoint != null) {
      objectEvent = util.putReadPoint(objectEvent, readPoint);
    }
    if (this.bizLocation != null) {
      objectEvent = util.putBizLocation(objectEvent, bizLocation);
    }
    if (this.bizTransactionList != null && this.bizTransactionList.isEmpty() == false) {
      objectEvent = util.putBizTransactionList(objectEvent, bizTransactionList);
    }
    if (this.ilmds != null && this.ilmds.isEmpty() == false) {
      objectEvent = util.putILMD(objectEvent, namespaces, ilmds);
    }
    if (this.extensions != null && this.extensions.isEmpty() == false) {
      objectEvent = util.putExtensions(objectEvent, namespaces, extensions);
    }

    BsonDocument extension = new BsonDocument();
    if (this.quantityList != null && this.quantityList.isEmpty() == false) {
      extension = util.putQuantityList(extension, quantityList);
    }
    if (this.sourceList != null && this.sourceList.isEmpty() == false) {
      extension = util.putSourceList(extension, sourceList);
    }
    if (this.destinationList != null && this.destinationList.isEmpty() == false) {
      extension = util.putDestinationList(extension, destinationList);
    }
    if (extension.isEmpty() == false) objectEvent.put("extension", extension);

    return objectEvent;
  }
Ejemplo n.º 13
0
 @Parameterized.Parameters(name = "{1}")
 public static Collection<Object[]> data() throws URISyntaxException, IOException {
   List<Object[]> data = new ArrayList<Object[]>();
   for (File file : JsonPoweredTestHelper.getTestFiles("/gridfs-tests")) {
     BsonDocument testDocument = JsonPoweredTestHelper.getTestDocument(file);
     for (BsonValue test : testDocument.getArray("tests")) {
       data.add(
           new Object[] {
             file.getName(),
             test.asDocument().getString("description").getValue(),
             testDocument.getDocument("data"),
             test.asDocument()
           });
     }
   }
   return data;
 }
 private BsonDocument getCommand(final ConnectionDescription description) {
   BsonDocument outputDocument =
       new BsonDocument(getAction(), new BsonString(getCollectionName()));
   outputDocument.append("sharded", BsonBoolean.valueOf(isSharded()));
   outputDocument.append("nonAtomic", BsonBoolean.valueOf(isNonAtomic()));
   if (getDatabaseName() != null) {
     outputDocument.put("db", new BsonString(getDatabaseName()));
   }
   BsonDocument commandDocument =
       new BsonDocument("mapreduce", new BsonString(namespace.getCollectionName()))
           .append("map", getMapFunction())
           .append("reduce", getReduceFunction())
           .append("out", outputDocument)
           .append("query", asValueOrNull(getFilter()))
           .append("sort", asValueOrNull(getSort()))
           .append("finalize", asValueOrNull(getFinalizeFunction()))
           .append("scope", asValueOrNull(getScope()))
           .append("verbose", BsonBoolean.valueOf(isVerbose()));
   putIfNotZero(commandDocument, "limit", getLimit());
   putIfNotZero(commandDocument, "maxTimeMS", getMaxTime(MILLISECONDS));
   putIfTrue(commandDocument, "jsMode", isJsMode());
   if (bypassDocumentValidation != null
       && description != null
       && serverIsAtLeastVersionThreeDotTwo(description)) {
     commandDocument.put(
         "bypassDocumentValidation", BsonBoolean.valueOf(bypassDocumentValidation));
   }
   if (description != null) {
     appendWriteConcernToCommand(writeConcern, commandDocument, description);
   }
   if (collation != null) {
     commandDocument.put("collation", collation.asDocument());
   }
   return commandDocument;
 }
  @Override
  public BsonValue getDocumentId(JsonObject json) {
    if (!documentHasId(json)) {
      throw new IllegalStateException("The document does not contain an _id");
    }

    Object id = json.getValue(ID_FIELD);
    if (id instanceof String) {
      return new BsonString((String) id);
    }

    BsonDocument idHoldingDocument = new BsonDocument();
    BsonWriter writer = new BsonDocumentWriter(idHoldingDocument);
    writer.writeStartDocument();
    writer.writeName(ID_FIELD);
    writeValue(writer, null, id, EncoderContext.builder().build());
    writer.writeEndDocument();
    return idHoldingDocument.get(ID_FIELD);
  }
Ejemplo n.º 16
0
  @Override
  public BsonValue getDocumentId(final Document document) {
    if (!documentHasId(document)) {
      throw new IllegalStateException("The document does not contain an _id");
    }

    Object id = document.get(ID_FIELD_NAME);
    if (id instanceof BsonValue) {
      return (BsonValue) id;
    }

    BsonDocument idHoldingDocument = new BsonDocument();
    BsonWriter writer = new BsonDocumentWriter(idHoldingDocument);
    writer.writeStartDocument();
    writer.writeName(ID_FIELD_NAME);
    writeValue(writer, EncoderContext.builder().build(), id);
    writer.writeEndDocument();
    return idHoldingDocument.get(ID_FIELD_NAME);
  }
Ejemplo n.º 17
0
  @Override
  public T execute(final InternalConnection connection) {
    if (LOGGER.isDebugEnabled()) {
      LOGGER.debug(
          format(
              "Sending command {%s : %s} to database %s on connection [%s] to server %s",
              getCommandName(),
              command.values().iterator().next(),
              namespace.getDatabaseName(),
              connection.getDescription().getConnectionId(),
              connection.getDescription().getServerAddress()));
    }
    long startTimeNanos = System.nanoTime();
    CommandMessage commandMessage =
        new CommandMessage(
            namespace.getFullName(),
            command,
            slaveOk,
            fieldNameValidator,
            ProtocolHelper.getMessageSettings(connection.getDescription()));
    ResponseBuffers responseBuffers = null;
    try {
      sendMessage(commandMessage, connection);
      responseBuffers = connection.receiveMessage(commandMessage.getId());
      if (!ProtocolHelper.isCommandOk(
          new BsonBinaryReader(new ByteBufferBsonInput(responseBuffers.getBodyByteBuffer())))) {
        throw getCommandFailureException(
            getResponseDocument(responseBuffers, commandMessage, new BsonDocumentCodec()),
            connection.getDescription().getServerAddress());
      }

      T retval = getResponseDocument(responseBuffers, commandMessage, commandResultDecoder);

      if (commandListener != null) {
        sendSucceededEvent(
            connection.getDescription(),
            startTimeNanos,
            commandMessage,
            getResponseDocument(responseBuffers, commandMessage, new RawBsonDocumentCodec()));
      }
      LOGGER.debug("Command execution completed");
      return retval;
    } catch (RuntimeException e) {
      sendFailedEvent(connection.getDescription(), startTimeNanos, commandMessage, e);
      throw e;
    } finally {
      if (responseBuffers != null) {
        responseBuffers.close();
      }
    }
  }
Ejemplo n.º 18
0
 @Override
 protected void appendToWriteCommandResponseDocument(
     final RequestMessage curMessage,
     final RequestMessage nextMessage,
     final WriteConcernResult writeConcernResult,
     final BsonDocument response) {
   response.append(
       "n",
       new BsonInt32(
           nextMessage == null
               ? ((InsertMessage) curMessage).getInsertRequestList().size()
               : ((InsertMessage) curMessage).getInsertRequestList().size()
                   - ((InsertMessage) nextMessage).getInsertRequestList().size()));
 }
Ejemplo n.º 19
0
 BsonDocument calculateKeys(final MappedClass mc, final Index index) {
   BsonDocument keys = new BsonDocument();
   for (Field field : index.fields()) {
     String path;
     try {
       path =
           findField(
               mc, index.options(), new ArrayList<String>(asList(field.value().split("\\."))));
     } catch (Exception e) {
       path = field.value();
       String message =
           format(
               "The path '%s' can not be validated against '%s' and may represent an invalid index",
               path, mc.getClazz().getName());
       if (!index.options().disableValidation()) {
         throw new MappingException(message);
       }
       LOG.warning(message);
     }
     keys.putAll(toBsonDocument(path, field.type().toIndexValue()));
   }
   return keys;
 }
Ejemplo n.º 20
0
  private void doDelete(final BsonDocument arguments, final BsonDocument assertion) {
    Throwable error = null;

    try {
      new MongoOperation<Void>() {
        @Override
        public void execute() {
          gridFSBucket.delete(arguments.getObjectId("id").getValue(), getCallback());
        }
      }.get();
    } catch (MongoGridFSException e) {
      error = e;
    }

    if (assertion.containsKey("error")) {
      assertNotNull("Should have thrown an exception", error);
    } else {
      assertNull("Should not have thrown an exception", error);
      for (BsonValue rawDataItem : assertion.getArray("data")) {
        BsonDocument dataItem = rawDataItem.asDocument();
        for (BsonValue deletedItem : dataItem.getArray("deletes", new BsonArray())) {
          String delete = dataItem.getString("delete", new BsonString("none")).getValue();
          BsonObjectId id = new BsonObjectId(new ObjectId());
          if (delete.equals("expected.files")) {
            id = deletedItem.asDocument().getDocument("q").getObjectId("_id");
          } else if (delete.equals("expected.chunks")) {
            id = deletedItem.asDocument().getDocument("q").getObjectId("files_id");
          }
          long filesCount = getFilesCount(new BsonDocument("_id", id));
          long chunksCount = getChunksCount(new BsonDocument("files_id", id));

          assertEquals(filesCount, 0);
          assertEquals(chunksCount, 0);
        }
      }
    }
  }
Ejemplo n.º 21
0
 @Override
 public void executeAsync(
     final InternalConnection connection, final SingleResultCallback<T> callback) {
   long startTimeNanos = System.nanoTime();
   CommandMessage message =
       new CommandMessage(
           namespace.getFullName(),
           command,
           slaveOk,
           fieldNameValidator,
           ProtocolHelper.getMessageSettings(connection.getDescription()));
   boolean sentStartedEvent = false;
   try {
     if (LOGGER.isDebugEnabled()) {
       LOGGER.debug(
           format(
               "Asynchronously sending command {%s : %s} to database %s on connection [%s] to server %s",
               getCommandName(),
               command.values().iterator().next(),
               namespace.getDatabaseName(),
               connection.getDescription().getConnectionId(),
               connection.getDescription().getServerAddress()));
     }
     ByteBufferBsonOutput bsonOutput = new ByteBufferBsonOutput(connection);
     int documentPosition =
         ProtocolHelper.encodeMessageWithMetadata(message, bsonOutput).getFirstDocumentPosition();
     sendStartedEvent(connection, bsonOutput, message, documentPosition);
     sentStartedEvent = true;
     SingleResultCallback<ResponseBuffers> receiveCallback =
         new CommandResultCallback(callback, message, connection.getDescription(), startTimeNanos);
     connection.sendMessageAsync(
         bsonOutput.getByteBuffers(),
         message.getId(),
         new SendMessageCallback<T>(
             connection,
             bsonOutput,
             message,
             getCommandName(),
             startTimeNanos,
             commandListener,
             callback,
             receiveCallback));
   } catch (Throwable t) {
     if (sentStartedEvent) {
       sendFailedEvent(connection.getDescription(), startTimeNanos, message, t);
     }
     callback.onResult(null, t);
   }
 }
Ejemplo n.º 22
0
  @Override
  public void encode(
      final BsonWriter writer, final BsonDocument value, final EncoderContext encoderContext) {
    writer.writeStartDocument();

    beforeFields(writer, encoderContext, value);
    for (Map.Entry<String, BsonValue> entry : value.entrySet()) {
      if (skipField(encoderContext, entry.getKey())) {
        continue;
      }

      writer.writeName(entry.getKey());
      writeValue(writer, encoderContext, entry.getValue());
    }

    writer.writeEndDocument();
  }
Ejemplo n.º 23
0
  private void actionGridFS(final BsonDocument action, final BsonDocument assertion) {
    if (action.isEmpty()) {
      return;
    }

    String operation = action.getString("operation").getValue();
    if (operation.equals("delete")) {
      doDelete(action.getDocument("arguments"), assertion);
    } else if (operation.equals("download")) {
      doDownload(action.getDocument("arguments"), assertion);
    } else if (operation.equals("download_by_name")) {
      doDownloadByName(action.getDocument("arguments"), assertion);
    } else if (operation.equals("upload")) {
      doUpload(action.getDocument("arguments"), assertion);
    } else {
      throw new IllegalArgumentException("Unknown operation: " + operation);
    }
  }
Ejemplo n.º 24
0
 @Override
 public BsonValue getDocumentId(final BsonDocument document) {
   return document.get(ID_FIELD_NAME);
 }
Ejemplo n.º 25
0
 private String getCommandName() {
   return commandName != null ? commandName : command.keySet().iterator().next();
 }
Ejemplo n.º 26
0
 private List<BsonDocument> processFiles(
     final BsonArray bsonArray, final List<BsonDocument> documents) {
   for (BsonValue rawDocument : bsonArray.getValues()) {
     if (rawDocument.isDocument()) {
       BsonDocument document = rawDocument.asDocument();
       if (document.get("length").isInt32()) {
         document.put("length", new BsonInt64(document.getInt32("length").getValue()));
       }
       if (document.containsKey("metadata") && document.getDocument("metadata").isEmpty()) {
         document.remove("metadata");
       }
       if (document.containsKey("aliases")
           && document.getArray("aliases").getValues().size() == 0) {
         document.remove("aliases");
       }
       if (document.containsKey("contentType")
           && document.getString("contentType").getValue().length() == 0) {
         document.remove("contentType");
       }
       documents.add(document);
     }
   }
   return documents;
 }
Ejemplo n.º 27
0
  private void doUpload(final BsonDocument rawArguments, final BsonDocument assertion) {
    Throwable error = null;
    ObjectId objectId = null;
    BsonDocument arguments = parseHexDocument(rawArguments, "source");
    try {
      final String filename = arguments.getString("filename").getValue();
      final InputStream inputStream =
          new ByteArrayInputStream(arguments.getBinary("source").getData());
      final GridFSUploadOptions options = new GridFSUploadOptions();
      BsonDocument rawOptions = arguments.getDocument("options", new BsonDocument());
      if (rawOptions.containsKey("chunkSizeBytes")) {
        options.chunkSizeBytes(rawOptions.getInt32("chunkSizeBytes").getValue());
      }
      if (rawOptions.containsKey("metadata")) {
        options.metadata(Document.parse(rawOptions.getDocument("metadata").toJson()));
      }

      objectId =
          new MongoOperation<ObjectId>() {
            @Override
            public void execute() {
              gridFSBucket.uploadFromStream(
                  filename, toAsyncInputStream(inputStream), options, getCallback());
            }
          }.get();
    } catch (Throwable e) {
      error = e;
    }

    if (assertion.containsKey("error")) {
      // We don't need to read anything more so don't see the extra chunk
      if (!assertion.getString("error").getValue().equals("ExtraChunk")) {
        assertNotNull("Should have thrown an exception", error);
      }
    } else {
      assertNull("Should not have thrown an exception", error);
      for (BsonValue rawDataItem : assertion.getArray("data", new BsonArray())) {
        BsonDocument dataItem = rawDataItem.asDocument();
        String insert = dataItem.getString("insert", new BsonString("none")).getValue();
        if (insert.equals("expected.files")) {
          List<BsonDocument> documents =
              processFiles(
                  dataItem.getArray("documents", new BsonArray()), new ArrayList<BsonDocument>());

          assertEquals(getFilesCount(new BsonDocument()), documents.size());
          BsonDocument actual =
              new MongoOperation<BsonDocument>() {
                @Override
                public void execute() {
                  filesCollection.find().first(getCallback());
                }
              }.get();
          for (BsonDocument expected : documents) {
            assertEquals(expected.get("length"), actual.get("length"));
            assertEquals(expected.get("chunkSize"), actual.get("chunkSize"));
            assertEquals(expected.get("md5"), actual.get("md5"));
            assertEquals(expected.get("filename"), actual.get("filename"));

            if (expected.containsKey("metadata")) {
              assertEquals(expected.get("metadata"), actual.get("metadata"));
            }
          }
        } else if (insert.equals("expected.chunks")) {
          List<BsonDocument> documents =
              processChunks(
                  dataItem.getArray("documents", new BsonArray()), new ArrayList<BsonDocument>());
          assertEquals(getChunksCount(new BsonDocument()), documents.size());

          List<BsonDocument> actualDocuments =
              new MongoOperation<List<BsonDocument>>() {
                @Override
                public void execute() {
                  chunksCollection.find().into(new ArrayList<BsonDocument>(), getCallback());
                }
              }.get();

          for (int i = 0; i < documents.size(); i++) {
            BsonDocument expected = documents.get(i);
            BsonDocument actual;
            actual = actualDocuments.get(i);
            assertEquals(new BsonObjectId(objectId), actual.getObjectId("files_id"));
            assertEquals(expected.get("n"), actual.get("n"));
            assertEquals(expected.get("data"), actual.get("data"));
          }
        }
      }
    }
  }
Ejemplo n.º 28
0
  private void arrangeGridFS(final BsonDocument arrange) {
    if (arrange.isEmpty()) {
      return;
    }
    for (BsonValue fileToArrange : arrange.getArray("data", new BsonArray())) {
      final BsonDocument document = fileToArrange.asDocument();
      if (document.containsKey("delete") && document.containsKey("deletes")) {
        for (BsonValue toDelete : document.getArray("deletes")) {
          final BsonDocument query = toDelete.asDocument().getDocument("q");
          int limit = toDelete.asDocument().getInt32("limit").getValue();

          final MongoCollection<BsonDocument> collection;
          if (document.getString("delete").getValue().equals("fs.files")) {
            collection = filesCollection;
          } else {
            collection = chunksCollection;
          }

          if (limit == 1) {
            new MongoOperation<DeleteResult>() {
              @Override
              public void execute() {
                collection.deleteOne(query, getCallback());
              }
            }.get();
          } else {
            new MongoOperation<DeleteResult>() {
              @Override
              public void execute() {
                collection.deleteMany(query, getCallback());
              }
            }.get();
          }
        }
      } else if (document.containsKey("insert") && document.containsKey("documents")) {
        if (document.getString("insert").getValue().equals("fs.files")) {
          new MongoOperation<Void>() {
            @Override
            public void execute() {
              filesCollection.insertMany(
                  processFiles(document.getArray("documents"), new ArrayList<BsonDocument>()),
                  getCallback());
            }
          }.get();
        } else {
          new MongoOperation<Void>() {
            @Override
            public void execute() {
              chunksCollection.insertMany(
                  processChunks(document.getArray("documents"), new ArrayList<BsonDocument>()),
                  getCallback());
            }
          }.get();
        }
      } else if (document.containsKey("update") && document.containsKey("updates")) {
        final MongoCollection<BsonDocument> collection;
        if (document.getString("update").getValue().equals("fs.files")) {
          collection = filesCollection;
        } else {
          collection = chunksCollection;
        }

        for (BsonValue rawUpdate : document.getArray("updates")) {
          final BsonDocument query = rawUpdate.asDocument().getDocument("q");
          final BsonDocument update = rawUpdate.asDocument().getDocument("u");
          update.put("$set", parseHexDocument(update.getDocument("$set")));
          new MongoOperation<UpdateResult>() {
            @Override
            public void execute() {
              collection.updateMany(query, update, getCallback());
            }
          }.get();
        }
      } else {
        throw new IllegalArgumentException("Unsupported arrange: " + document);
      }
    }
  }
Ejemplo n.º 29
0
 @Test
 public void shouldPassAllOutcomes() {
   arrangeGridFS(definition.getDocument("arrange", new BsonDocument()));
   actionGridFS(definition.getDocument("act"), definition.getDocument("assert"));
 }
Ejemplo n.º 30
0
 @Override
 public boolean documentHasId(final BsonDocument document) {
   return document.containsKey(ID_FIELD_NAME);
 }