Java 类org.apache.http.HttpStatus 实例源码

@Test
public void testConsumerInNonExistingQueue() throws Exception {
    String queueName = "testConsumerInNonExistingQueue";
    HttpGet httpGet = new HttpGet(apiBasePath + QueuesApiDelegate.QUEUES_API_PATH
                                          + "/" + queueName + "/consumers");

    CloseableHttpResponse response = client.execute(httpGet);

    Assert.assertEquals(response.getStatusLine().getStatusCode(), HttpStatus.SC_NOT_FOUND,
                        "Incorrect status code");
    String body = EntityUtils.toString(response.getEntity());
    Error error = objectMapper.readValue(body, Error.class);

    Assert.assertFalse(error.getMessage().isEmpty(), "Error message shouldn't be empty.");

}

/**
 * WebDAVにGETを指定してXHR2ヘッダーのALLOW_ORIGINのみ返却されること.
 */
@Test
public final void WebDAVにGETを指定してXHR2ヘッダーのALLOW_ORIGINのみ返却されること() {
    try {
        // コレクションの作成
        createDavCollection();

        TResponse response =
                Http.request("crossdomain/xhr2-preflight-no-access-control-allow-headers.txt")
                        .with("path", "/testcell1/box1/davcol/test.txt")
                        .with("token", PersoniumUnitConfig.getMasterToken())
                        .returns()
                        .statusCode(HttpStatus.SC_NOT_FOUND)
                        .debug();
        checkXHR2HeaderOnlyOrigin(response);
    } finally {
        // コレクションの削除
        deleteDavCollection();
    }
}

/**
 * Check the JAX-RS validation reject the null object in POST
 */
@Test
public void testValidationFilterFailedNull() throws IOException {
    final HttpPost httppost = new HttpPost(BASE_URI + RESOURCE);
    httppost.setHeader("Content-Type", "application/json");
    httppost.setHeader(ACCEPT_LANGUAGE, "EN");
    final HttpResponse response = httpclient.execute(httppost);
    Assert.assertEquals(HttpStatus.SC_BAD_REQUEST, response.getStatusLine().getStatusCode());
    final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8);
    Assert.assertNotNull(content);
    @SuppressWarnings("all")
    final Map<String, Map<String, List<Map<String, Object>>>> result = (Map<String, Map<String, List<Map<String, Object>>>>) new ObjectMapperTrim()
            .readValue(content, HashMap.class);

    Assert.assertFalse(result.isEmpty());
    final Map<String, List<Map<String, Object>>> errors = result.get("errors");
    Assert.assertNotNull(errors);
    Assert.assertEquals(1, errors.size());
    log.info("### ENTRY ####" + errors.keySet().iterator().next());
    Assert.assertNotNull(errors.get("wine"));
    Assert.assertEquals(1, ((List<?>) errors.get("wine")).size());
    Assert.assertEquals(1, ((Map<?, ?>) ((List<?>) errors.get("wine")).get(0)).size());
    Assert.assertEquals(((Map<?, ?>) ((List<?>) errors.get("wine")).get(0)).get(RULE), "NotNull");
}

/**
 * 親コレクションにread権限がある_かつ_対象ファイルにread権限があるアカウントでファイルの取得ができること.
 * @throws JAXBException ACLのパース失敗
 */
@Test
public void 親コレクションにread権限がある_かつ_対象ファイルにread権限があるアカウントでファイルの取得ができること() throws JAXBException {
    String token;
    String path = String.format("%s/%s", PARENT_COL_NAME, TARGET_FILE_NAME);

    // ACL設定
    setAcl(PARENT_COL_NAME, ROLE, "read");
    setAcl(path, ROLE, "read");

    // アクセストークン取得
    token = getToken(ACCOUNT);

    // リクエスト実行
    DavResourceUtils.getWebDav(CELL_NAME, token, BOX_NAME, path, HttpStatus.SC_OK);
}

/**
 * レスポンスコードの説明を取得する.
 * @return レスポンスコードの説明（例：OK, No Content）
 */
public String getResponseMessage() {
    String message = null;

    switch (this.responseCode) {
    case HttpStatus.SC_NO_CONTENT:
        message = "No Content";
        break;

    case HttpStatus.SC_CREATED:
        message = "Created";
        break;

    case HttpStatus.SC_OK:
        message = "OK";
        break;

    default:
        message = "";
        break;
    }

    return message;
}

/**
 * $skipに空文字を指定してUserDataの一覧をした場合に400エラーとなること.
 */
@Test
public final void $skipに空文字を指定してUserDataの一覧をした場合に400エラーとなること() {
    // ユーザデータの一覧取得
    TResponse res = Http.request("box/odatacol/list.txt")
            .with("cell", cellName)
            .with("box", boxName)
            .with("collection", colName)
            .with("entityType", entityTypeName)
            .with("query", "?\\$skip=")
            .with("accept", MediaType.APPLICATION_JSON)
            .with("token", PersoniumUnitConfig.getMasterToken())
            .returns()
            .statusCode(HttpStatus.SC_BAD_REQUEST)
            .debug();
    ODataCommon.checkErrorResponseBody(res, PersoniumCoreException.OData.QUERY_PARSE_ERROR_WITH_PARAM.getCode(),
            PersoniumCoreException.OData.QUERY_PARSE_ERROR_WITH_PARAM.params("$skip").getMessage());
}

@Override
public boolean isValidEndPoint(final URL url) {
    Assert.notNull(this.httpClient);

    HttpEntity entity = null;

    try (final CloseableHttpResponse response = this.httpClient.execute(new HttpGet(url.toURI()))) {
        final int responseCode = response.getStatusLine().getStatusCode();

        for (final int acceptableCode : this.acceptableCodes) {
            if (responseCode == acceptableCode) {
                LOGGER.debug("Response code from server matched {}.", responseCode);
                return true;
            }
        }

        LOGGER.debug("Response code did not match any of the acceptable response codes. Code returned was {}",
                responseCode);

        if (responseCode == HttpStatus.SC_INTERNAL_SERVER_ERROR) {
            final String value = response.getStatusLine().getReasonPhrase();
            LOGGER.error("There was an error contacting the endpoint: {}; The error was:\n{}", url.toExternalForm(),
                    value);
        }

        entity = response.getEntity();
    } catch (final Exception e) {
        LOGGER.error(e.getMessage(), e);
    } finally {
        EntityUtils.consumeQuietly(entity);
    }
    return false;
}

/**
 * $batchの登録で不正フォーマットのデータを指定した場合に400が返却されること.
 */
@Test
public final void $batchの登録で不正フォーマットのデータを指定した場合に400が返却されること() {
    String body = START_BOUNDARY;
    String code = PersoniumCoreException.OData.BATCH_BODY_PARSE_ERROR.getCode();
    String err = PersoniumCoreException.OData.BATCH_BODY_PARSE_ERROR.getMessage();
    Http.request("box/odatacol/batch.txt")
            .with("cell", cellName)
            .with("box", boxName)
            .with("collection", colName)
            .with("boundary", BOUNDARY)
            .with("token", PersoniumUnitConfig.getMasterToken())
            .with("body", body)
            .returns()
            .statusCode(HttpStatus.SC_BAD_REQUEST)
            .checkErrorResponse(code, err);

}

/**
 * .
 */
@Test
public final void セル一括削除時にX_PERSONIUM_Recursiveヘッダにfalseを指定して412が返却されること() {
    // セルを作成する
    String cellName = "CellBulkDeletionTest";
    CellUtils.create(cellName, MASTER_TOKEN_NAME, -1);

    // セルの一括削除APIを実行する
    PersoniumRequest request = PersoniumRequest.delete(UrlUtils.cellRoot(cellName));
    request.header(HttpHeaders.AUTHORIZATION, BEARER_MASTER_TOKEN)
            .header("X-Personium-Recursive", "false");
    PersoniumResponse response = request(request);

    // セル削除APIを実行して、412が返却されることを確認
    try {
        assertEquals(HttpStatus.SC_PRECONDITION_FAILED, response.getStatusCode());
        ODataCommon.checkErrorResponseBody(response, PersoniumCoreException.Misc.PRECONDITION_FAILED.getCode(),
                PersoniumCoreException.Misc.PRECONDITION_FAILED
                        .params(PersoniumCoreUtils.HttpHeaders.X_PERSONIUM_RECURSIVE)
                        .getMessage());
    } finally {
        // セルを削除する
        request.header("X-Personium-Recursive", "true");
        request(request);
    }
}

/**
 * testの後に実行する.
 */
@After
public final void afterCell() {
    PersoniumResponse res = null;
    if (this.cellInfo.cellId != null) {
        if (this.cellInfo.boxName != null) {
            // テストBox 削除
            res = restDelete(UrlUtils.cellCtl(this.cellInfo.cellName, Box.EDM_TYPE_NAME, this.cellInfo.boxName));
        }
        // テストCell 削除
        res = restDelete(UrlUtils.unitCtl(Cell.EDM_TYPE_NAME, this.cellInfo.cellId));
        // レスポンスコードのチェック
        if ((res.getStatusCode() == HttpStatus.SC_NO_CONTENT)
                || (res.getStatusCode() == HttpStatus.SC_OK)) {
            this.cellInfo.initial();
        }
        assertEquals(HttpStatus.SC_NO_CONTENT, res.getStatusCode());
    }
}

/**
 * ユニットローカルユニットユーザトークン認証でパスワード変更を実行し403が返ること.
 * @throws TokenParseException 認証用トークンのパースエラー
 */
@Test
@Ignore // UUT promotion setting API invalidation.
public final void ユニットローカルユニットユーザトークン認証でパスワード変更を実行し403が返ること() throws TokenParseException {
    // 認証
    // アカウントにユニット昇格権限付与
    DavResourceUtils.setProppatch(Setup.TEST_CELL1, MASTER_TOKEN,
            "cell/proppatch-uluut.txt", HttpStatus.SC_MULTI_STATUS);

    // パスワード認証でのユニット昇格
    TResponse tokenResponse = Http.request("authnUnit/password-uluut.txt")
            .with("remoteCell", Setup.TEST_CELL1)
            .with("username", "account1")
            .with("password", "password1")
            .returns()
            .statusCode(HttpStatus.SC_OK);

    JSONObject json = tokenResponse.bodyAsJson();
    String uluut = (String) json.get(OAuth2Helper.Key.ACCESS_TOKEN);

    // ユニットローカルユニットユーザトークンを取得する
    PersoniumResponse res = requesttoMypassword(uluut, "password3", Setup.TEST_CELL1);
    assertEquals(403, res.getStatusCode());
}

/**
 * Gets a part of the given URL, writes the content into the given channel.
 * Fails if the returned HTTP status is not "206 partial content".
 *
 * @param <IWC> a generic type for any class that implements InterruptibleChannel and WritableByteChannel
 * @param url to get
 * @param output written with the content of the HTTP response
 * @param etag value of the If-Range header
 * @param range_start range byte start (inclusive)
 * @param range_end range byte end (inclusive)
 *
 * @return a response (contains the HTTP Headers, the status code, ...)
 *
 * @throws IOException IO error
 * @throws InterruptedException interrupted
 * @throws RuntimeException containing the actual exception if it is not an instance of IOException
 */
public <IWC extends InterruptibleChannel & WritableByteChannel>
      HttpResponse interruptibleGetRange(String url, final IWC output, String etag, long range_start, long range_end)
      throws IOException, InterruptedException
{
   HttpGet get = new HttpGet(url);
   get.setHeader("If-Range", etag);
   get.setHeader("Range", String.format("bytes=%d-%d", range_start, range_end));
   // This validator throws an IOException if the response code is not 206 partial content
   ResponseValidator val = new ResponseValidator()
   {
      @Override
      public void validate(HttpResponse response) throws HttpException, IOException
      {
         if (response.getStatusLine().getStatusCode() != HttpStatus.SC_PARTIAL_CONTENT)
         {
            throw new IOException("Range request does not return partial content");
         }
      }
   };
   return interruptibleRequest(get, output, val);
}

/**
 * @see ExceptionMapperResource#throwWebApplication()
 */
@Test
public void testJaxRS405Error() throws IOException {
    final HttpGet httpget = new HttpGet(BASE_URI + RESOURCE + "/jax-rs");
    HttpResponse response = null;
    try {
        response = httpclient.execute(httpget);
        Assert.assertEquals(HttpStatus.SC_METHOD_NOT_ALLOWED, response.getStatusLine().getStatusCode());
        final String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8);
        final Map<?, ?> result = new ObjectMapperTrim().readValue(content, HashMap.class);
        Assert.assertEquals("internal", result.get("code"));
        Assert.assertNull(result.get("cause"));
        Assert.assertEquals("HTTP 405 Method Not Allowed", result.get("message"));
    } finally {
        if (response != null) {
            response.getEntity().getContent().close();
        }
    }
}

/**
 * デフォルトログが存在しないときにファイルに対するGETで200が返却されること.
 */
@Test
public final void デフォルトログが存在しないときにファイルに対するGETで200が返却されること() {
    try {
        // Cell作成
        CellUtils.create("TestCellForLogNotFound", MASTER_TOKEN_NAME, HttpStatus.SC_CREATED);

        TResponse response = Http.request("cell/log-get.txt")
                .with("METHOD", HttpMethod.GET)
                .with("token", AbstractCase.MASTER_TOKEN_NAME)
                .with("cellPath", "TestCellForLogNotFound")
                .with("collection", CURRENT_COLLECTION)
                .with("fileName", DEFAULT_LOG)
                .with("ifNoneMatch", "*")
                .returns();
        response.debug();
        response.statusCode(HttpStatus.SC_OK);
        String responseBody = response.getBody();
        // 空のレスポンスボディが返されることを確認
        assertEquals(0, responseBody.length());
    } finally {
        // Cell削除
        CellUtils.delete(MASTER_TOKEN_NAME, "TestCellForLogNotFound");
    }

}

/**
 * ComplexTypePropertyの_ComplexTypeNameが半角英数字以外の場合_BadRequestが返却されること.
 */
@Test
public final void ComplexTypePropertyの_ComplexTypeNameが半角英数字以外の場合_BadRequestが返却されること() {
    // リクエストパラメータ設定
    PersoniumRequest req = PersoniumRequest.post(ComplexTypePropertyUtils.CTP_REQUEST_URL);
    req.header(HttpHeaders.AUTHORIZATION, BEARER_MASTER_TOKEN);
    req.addJsonBody(ComplexTypePropertyUtils.CT_PROPERTY_NAME_KEY, CT_PROPERTY_NAME);
    req.addJsonBody(ComplexTypePropertyUtils.CT_PROPERTY_COMPLEXTYPE_NAME_KEY, "Ad.*s");
    req.addJsonBody(ComplexTypePropertyUtils.CT_PROPERTY_TYPE_KEY,
            EdmSimpleType.STRING.getFullyQualifiedTypeName());
    req.addJsonBody(ComplexTypePropertyUtils.CT_PROPERTY_NULLABLE_KEY, null);
    req.addJsonBody(ComplexTypePropertyUtils.CT_PROPERTY_DEFAULT_VALUE_KEY, null);
    req.addJsonBody(ComplexTypePropertyUtils.CT_PROPERTY_COLLECTION_KIND_KEY, null);

    // リクエスト実行
    PersoniumResponse response = request(req);

    // レスポンスチェック
    assertEquals(HttpStatus.SC_BAD_REQUEST, response.getStatusCode());
    checkErrorResponse(
            response.bodyAsJson(),
            PersoniumCoreException.OData.REQUEST_FIELD_FORMAT_ERROR.getCode(),
            PersoniumCoreException.OData.REQUEST_FIELD_FORMAT_ERROR.params(
                    ComplexTypePropertyUtils.CT_PROPERTY_COMPLEXTYPE_NAME_KEY).getMessage());
}

/**
 * UserData一覧取得で$orderbyに文字列配列型のプロパティを指定した場合に400エラーとなること.
 */
@Test
public final void UserData一覧取得で$orderbyに文字列配列型のプロパティを指定した場合に400エラーとなること() {
    String cell = Setup.TEST_CELL1;
    String box = Setup.TEST_BOX1;
    String collection = Setup.SEARCH_ODATA;

    // 文字列配列型のEntityTypeに対して、登録されたプロパティをソート条件に指定する
    String entityType = "stringList";
    String query = "?\\$orderby=property3";
    TResponse response =
            UserDataUtils.list(cell, box, collection, entityType, query, MASTER_TOKEN_NAME,
                    HttpStatus.SC_BAD_REQUEST);
    checkErrorResponse(response.bodyAsJson(),
            PersoniumCoreException.OData.CANNOT_SPECIFY_THE_LIST_TYPE_TO_ORDERBY.getCode(),
            PersoniumCoreException.OData.CANNOT_SPECIFY_THE_LIST_TYPE_TO_ORDERBY.getMessage());
}

/**
 * Account新規登録時に不正なパスワード文字列を指定して400になること.
 */
@Test
public final void Account新規登録時に不正なパスワード文字列を指定して400になること() {
    ArrayList<String> invalidStrings = new ArrayList<String>();
    invalidStrings.add("password=");
    invalidStrings.add("");
    invalidStrings.add("!aa");
    invalidStrings.add("pass%word");
    invalidStrings.add("%E3%81%82");
    invalidStrings.add("あ");
    invalidStrings.add("123456789012345678901234567890123");

    String testAccountName = "account_badpassword";
    String accLocHeader = null;

    try {
        for (String value : invalidStrings) {
            accLocHeader = createAccount(testAccountName, value, HttpStatus.SC_BAD_REQUEST);
        }
    } finally {
        if (accLocHeader != null) {
            deleteAccount(accLocHeader);
        }
    }
}

/**
 * UserData一覧取得で$orderbyにプロパティ名を文字列で指定した場合にステータスコード400が返却されること.
 */
@Test
public final void UserData一覧取得で$orderbyにプロパティ名を文字列で指定した場合にステータスコード400が返却されること() {
    // ユーザデータの一覧取得
    String sdEntityTypeName = "SalesDetail";

    Http.request("box/odatacol/list.txt")
            .with("cell", cellName)
            .with("box", boxName)
            .with("collection", colName)
            .with("entityType", sdEntityTypeName)
            .with("query", "?\\$orderby=%27test%27")
            .with("accept", MediaType.APPLICATION_JSON)
            .with("token", PersoniumUnitConfig.getMasterToken())
            .returns()
            .statusCode(HttpStatus.SC_BAD_REQUEST)
            .debug();
}

/**
 * 親コレクションに権限がない_かつ_対象ファイルにwrite権限があるアカウントでファイルのDELETEを行い403エラーとなること.
 * @throws JAXBException ACLのパース失敗
 */
@Test
public void 親コレクションに権限がない_かつ_対象ファイルにwrite権限があるアカウントでファイルのDELETEを行い403エラーとなること() throws JAXBException {
    String token;
    String path = String.format("%s/%s", PARENT_COL_NAME, TARGET_FILE_NAME);

    // ACL設定
    setAcl(path, ROLE, "write");

    // アクセストークン取得
    token = getToken(ACCOUNT);

    // リクエスト実行
    TResponse res = DavResourceUtils.deleteWebDavFile(CELL_NAME, token, BOX_NAME, path);
    assertThat(res.getStatusCode()).isEqualTo(HttpStatus.SC_FORBIDDEN);
    PersoniumCoreException expectedException = PersoniumCoreException.Auth.NECESSARY_PRIVILEGE_LACKING;
    ODataCommon.checkErrorResponseBody(res, expectedException.getCode(), expectedException.getMessage());
}

/**
 * ユーザODataのNavigationProperty経由一覧取得でexpandに最大プロパティ数を指定した場合正常に取得できること.
 */
@Test
public final void ユーザODataのNavigationProperty経由一覧取得でexpandに最大プロパティ数を指定した場合正常に取得できること() {
    String cell = Setup.TEST_CELL1;
    String box = Setup.TEST_BOX1;
    String collection = Setup.TEST_ODATA;

    String fromEntity = "SalesDetail";
    String toEntity = "Sales";
    String expandEntity1 = "Price";
    String expandEntity2 = "Product";
    String fromUserDataId = "userdata000";

    // NP経由一覧取得($expand)
    String expands = String.format("?\\$expand=_%s,_%s", expandEntity1, expandEntity2);
    UserDataUtils.listViaNP(cell, box, collection, fromEntity, fromUserDataId, toEntity, expands,
            HttpStatus.SC_OK);
}

/**
 * UserDataの新規作成時IDに有効桁長の最小値を指定した場合201になること.
 */
@SuppressWarnings("unchecked")
@Test
public final void UserDataの新規作成時IDに有効桁長の最小値を指定した場合201になること() {
    String userDataId = "1";

    JSONObject body = new JSONObject();
    body.put("__id", userDataId);
    body.put("dynamicProperty", "dynamicPropertyValue");

    String locationHeader = null;

    try {
        TResponse res = createUserData(body);
        locationHeader = res.getLocationHeader();
        res.statusCode(HttpStatus.SC_CREATED);

    } finally {
        if (locationHeader != null) {
            deleteOdataResource(locationHeader);
        }
    }
}

/**
 * ComplexTypePropertyの_ComplexTypeName属性がない場合_BadRequestが返却されること.
 */
@Test
public final void ComplexTypePropertyの_ComplexTypeName属性がない場合_BadRequestが返却されること() {
    // リクエストパラメータ設定
    PersoniumRequest req = PersoniumRequest.post(ComplexTypePropertyUtils.CTP_REQUEST_URL);
    req.header(HttpHeaders.AUTHORIZATION, BEARER_MASTER_TOKEN);
    req.addJsonBody(ComplexTypePropertyUtils.CT_PROPERTY_NAME_KEY, CT_PROPERTY_NAME);
    req.addJsonBody(ComplexTypePropertyUtils.CT_PROPERTY_TYPE_KEY,
            EdmSimpleType.STRING.getFullyQualifiedTypeName());
    req.addJsonBody(ComplexTypePropertyUtils.CT_PROPERTY_NULLABLE_KEY, null);
    req.addJsonBody(ComplexTypePropertyUtils.CT_PROPERTY_DEFAULT_VALUE_KEY, null);
    req.addJsonBody(ComplexTypePropertyUtils.CT_PROPERTY_COLLECTION_KIND_KEY, null);

    // リクエスト実行
    PersoniumResponse response = request(req);

    // レスポンスチェック
    assertEquals(HttpStatus.SC_BAD_REQUEST, response.getStatusCode());
    checkErrorResponse(
            response.bodyAsJson(),
            PersoniumCoreException.OData.INPUT_REQUIRED_FIELD_MISSING.getCode(),
            PersoniumCoreException.OData.INPUT_REQUIRED_FIELD_MISSING.params(
                    ComplexTypePropertyUtils.CT_PROPERTY_COMPLEXTYPE_NAME_KEY)
                    .getMessage());
}

/**
 * Boxに結びつかないRoleをexpandで展開できること.
 */
@Test
public final void Boxに結びつかないRoleをexpandで展開できること() {
    final String roleName = "boxLinkRole";
    try {
        // Role作成
        RoleUtils.create(CELL_NAME, TOKEN, roleName, null, HttpStatus.SC_CREATED);

        // Boxに紐付くRoleのlink一覧取得
        RoleUtils.list(TOKEN, CELL_NAME, "\\$expand=_Box&\\$filter=startswith(Name,'boxLinkRole')",
                HttpStatus.SC_OK);
    } finally {
        // ロールの削除
        RoleUtils.delete(CELL_NAME, TOKEN, roleName, null, -1);
    }
}

/**
 * AssociationEndの新規作成時_EntityType.Nameに指定可能な文字数の最小値を指定した場合201となること.
 */
@Test
public final void AssociationEndの新規作成時EntityType名に指定可能な文字数の最小値を指定した場合201となること() {
    String assocName = ASSOCIATION_END_NAME;
    String multiplicity = EdmMultiplicity.MANY.getSymbolString();
    String entityTypeName = "1";
    String locationHeader = null;
    String locationHeaderEntityType = null;

    try {
        TResponse resEntityType = createEntityType(entityTypeName);
        locationHeaderEntityType = resEntityType.getLocationHeader();

        TResponse res = createAssociationEnd(assocName, multiplicity, entityTypeName);
        locationHeader = res.getLocationHeader();
        res.statusCode(HttpStatus.SC_CREATED);
    } finally {
        if (locationHeader != null) {
            deleteOdataResource(locationHeader);
        }
        if (locationHeaderEntityType != null) {
            deleteOdataResource(locationHeaderEntityType);
        }
    }
}

/**
 * DefaultValueに制御コードを含むComplexTypePropertyをNP経由で作成した場合_レスポンスボディがエスケープされて返却されること.
 */
@Test
public final void DefaultValueに制御コードを含むComplexTypePropertyをNP経由で作成した場合_レスポンスボディがエスケープされて返却されること() {
    String ctplocationUrl =
            UrlUtils.complexTypeProperty(Setup.TEST_CELL1, Setup.TEST_BOX1, Setup.TEST_ODATA,
                    CT_PROPERTY_NAME,
                    COMPLEX_TYPE_NAME);

    try {
        TResponse response = ComplexTypePropertyUtils.createViaComplexTypePropertyNP(
                BEARER_MASTER_TOKEN, Setup.TEST_CELL1, Setup.TEST_BOX1, Setup.TEST_ODATA,
                COMPLEX_TYPE_NAME, CT_PROPERTY_NAME, EdmSimpleType.STRING.getFullyQualifiedTypeName(),
                false, "\\u0000", Property.COLLECTION_KIND_NONE, 201);

        // レスポンスチェック
        String resBody = response.getBody();
        assertTrue(resBody.contains("\\u0000"));
        assertFalse(resBody.contains("\u0000"));
    } finally {
        // 作成したComplexTypePropertyを削除
        assertEquals(HttpStatus.SC_NO_CONTENT, deleteOdataResource(ctplocationUrl).getStatusCode());
    }
}

/**
 * Cellの更新の$formatがatomのテスト.
 */
@SuppressWarnings("unchecked")
@Test
public final void Cellの更新の$formatがatomのテスト() {

    // Cellを更新
    // リクエストヘッダをセット
    HashMap<String, String> headers = new HashMap<String, String>();
    headers.put(HttpHeaders.AUTHORIZATION, BEARER_MASTER_TOKEN);
    headers.put(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_ATOM_XML);
    headers.put(HttpHeaders.IF_MATCH, "*");

    // リクエストボディを生成
    JSONObject requestBody = new JSONObject();
    requestBody.put("Name", cellName);
    res = updateCellQuery(headers, requestBody, QUERY_FORMAT_ATOM);

    // Cell更新のレスポンスチェック
    // TODO $formatのチェックが実装されたら変更する必要がある
    assertEquals(HttpStatus.SC_NO_CONTENT, res.getStatusCode());

}

/**
 * Cell取得した場合にatomフォーマットでレスポンスが返却されること. $format → atom Accept → application/atom+xml
 */
@Test
public final void ＄formatがatomかつacceptがjsonでCell取得した場合にatomフォーマットでレスポンスが返却されること() {
    String url = getUrl(this.cellId);
    // $format atom
    // Acceptヘッダ application/json
    HashMap<String, String> headers = new HashMap<String, String>();
    headers.put(HttpHeaders.AUTHORIZATION, BEARER_MASTER_TOKEN);
    headers.put(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON);
    this.setHeaders(headers);

    PersoniumResponse res = this.restGet(url + "?" + QUERY_FORMAT_ATOM);

    assertEquals(HttpStatus.SC_OK, res.getStatusCode());
    this.responseHeaderMap.put(HTTP.CONTENT_TYPE, MediaType.APPLICATION_ATOM_XML);
    this.checkHeaders(res);
    // Etagのチェック
    assertEquals(1, res.getResponseHeaders(HttpHeaders.ETAG).length);
    res.bodyAsXml();
}

/**
 * barファイルのルートディレクトリがbarではない場合に異常終了すること.
 */
@Test
public final void barファイルのルートディレクトリがbarではない場合に異常終了すること() {
    String reqCell = Setup.TEST_CELL1;
    String reqPath = INSTALL_TARGET;

    TResponse res = null;
    File barFile = new File(RESOURCE_PATH + BAR_FILE_WRONGDIR);
    byte[] body = BarInstallTestUtils.readBarFile(barFile);
    Map<String, String> headers = new LinkedHashMap<String, String>();
    headers.put(HttpHeaders.CONTENT_TYPE, REQ_CONTENT_TYPE);
    headers.put(HttpHeaders.CONTENT_LENGTH, String.valueOf(body.length));

    res = BarInstallTestUtils.request(REQUEST_NORM_FILE, reqCell, reqPath, headers, body);

    res.statusCode(HttpStatus.SC_BAD_REQUEST);
    String code = PersoniumCoreException.BarInstall.BAR_FILE_INVALID_STRUCTURES.getCode();
    String message = PersoniumCoreException.BarInstall.BAR_FILE_INVALID_STRUCTURES.
            params("bar/ bar/00_meta/ bar/00_meta/00_manifest.json bar/00_meta/90_rootprops.xml").getMessage();
    res.checkErrorResponse(code, message);
}

/**
 * $batchの登録でリクエストボディの末尾にバウンダリーがない場合に400が返却されること.
 */
@Test
public final void $batchの登録でリクエストボディの末尾にバウンダリーがない場合に400が返却されること() {
    String code = PersoniumCoreException.OData.BATCH_BODY_PARSE_ERROR.getCode();
    String err = PersoniumCoreException.OData.BATCH_BODY_PARSE_ERROR.getMessage();
    String body = START_BOUNDARY + BatchUtils.retrieveDeleteBody("Supplier('testBatch1')");
    Http.request("box/odatacol/batch.txt")
            .with("cell", cellName)
            .with("box", boxName)
            .with("collection", colName)
            .with("boundary", "changeset_cLzcDEEVPwvvoxS3yJTFTpRauSK_FAQ6mQtyo0aby93-SDP3lAs2A19a2uBb")
            .with("token", PersoniumUnitConfig.getMasterToken())
            .with("body", body)
            .returns()
            .statusCode(HttpStatus.SC_BAD_REQUEST)
            .checkErrorResponse(code, err)
            .debug();
}

@Test
public void findAllByName() throws Exception {
    prepareMockHome();
    httpServer.stubFor(post(urlEqualTo("/dologin.action"))
            .willReturn(aResponse().withStatus(HttpStatus.SC_MOVED_TEMPORARILY).withHeader("Location", "/")));

    httpServer.stubFor(get(urlEqualTo("/rest/api/space?type=global&limit=100&start=0"))
            .willReturn(aResponse().withStatus(HttpStatus.SC_OK).withBody(IOUtils.toString(
                    new ClassPathResource("mock-server/confluence/confluence-spaces.json").getInputStream(), StandardCharsets.UTF_8))));
    httpServer.stubFor(
            get(urlEqualTo("/rest/api/space?type=global&limit=100&start=100")).willReturn(aResponse().withStatus(HttpStatus.SC_OK)
                    .withBody(IOUtils.toString(new ClassPathResource("mock-server/confluence/confluence-spaces2.json").getInputStream(),
                            StandardCharsets.UTF_8))));
    httpServer.start();

    final List<Space> projects = resource.findAllByName("service:km:confluence:dig", "p");
    Assert.assertEquals(10, projects.size());
    checkSpace(projects.get(4));
}

/**
 * 移動元Collectionにwrite権限を持つアカウントでファイルのMOVEをした場合201となること.
 * @throws JAXBException ACLのパース失敗
 */
@Test
public void 移動元Collectionにwrite権限を持つアカウントでファイルのMOVEをした場合201となること() throws JAXBException {
    String token;
    String path = String.format("%s/%s/%s", BOX_NAME, SRC_COL_NAME, FILE_NAME);
    String destination = UrlUtils.box(CELL_NAME, BOX_NAME, DST_COL_NAME, FILE_NAME);

    try {
        // 事前準備
        setDefaultAcl(SRC_COL_NAME);
        setPrincipalAllAcl(DST_COL_NAME);

        DavResourceUtils.createWebDavFile(MASTER_TOKEN, CELL_NAME, path, FILE_BODY, MediaType.TEXT_PLAIN,
                HttpStatus.SC_CREATED);

        // write権限→201
        token = getToken(ACCOUNT_WRITE);
        DavResourceUtils.moveWebDav(token, CELL_NAME, path, destination, HttpStatus.SC_CREATED);

    } finally {
        DavResourceUtils.deleteWebDavFile(CELL_NAME, MASTER_TOKEN, BOX_NAME, DST_COL_NAME + "/" + FILE_NAME);
    }
}

/**
 * ODataのコレクション作成テスト.
 */
@Test
public final void ODataのコレクション作成テスト() {

    String path = "odatacol";
    try {
        // コレクションの作成
        Http.request("box/mkcol-odata.txt")
                .with("cellPath", "testcell1")
                .with("boxPath", "box1")
                .with("path", path)
                .with("token", TOKEN)
                .returns()
                .statusCode(HttpStatus.SC_CREATED);

        // コレクションの取得（bodyあり）
        TResponse tresponseAll = Http.request("box/propfind-col-allprop.txt")
                .with("path", path)
                .with("depth", "0")
                .with("token", TOKEN)
                .returns();
        tresponseAll.statusCode(HttpStatus.SC_MULTI_STATUS);

        // p:odata の存在チェック
        serviceColTypeTest(tresponseAll.bodyAsXml(), "p:odata");
    } finally {

        // Boxの削除
        deleteTest(path, -1);
    }
}

/**
 * Normal test.
 * Recursive delete OData collection.
 */
@Test
public void normal_recursive_delete_OData_collection() {
    String collectionName = "deleteOdata";
    String entityType = "deleteEntType";
    String accept = "application/xml";
    String complexTypeName = "deleteComplexType";
    String complexTypePropertyName = "deleteComplexTypeProperty";

    try {
        // Create collection.
        DavResourceUtils.createODataCollection(TOKEN, HttpStatus.SC_CREATED, Setup.TEST_CELL1, Setup.TEST_BOX1,
                collectionName);
        // Create entity type.
        Http.request("box/entitySet-post.txt")
                .with("cellPath", Setup.TEST_CELL1)
                .with("boxPath", Setup.TEST_BOX1)
                .with("odataSvcPath", collectionName)
                .with("token", "Bearer " + TOKEN)
                .with("accept", accept)
                .with("Name", entityType)
                .returns()
                .statusCode(HttpStatus.SC_CREATED);
        // Create complex type.
        ComplexTypeUtils.create(Setup.TEST_CELL1, Setup.TEST_BOX1,
                collectionName, complexTypeName, HttpStatus.SC_CREATED);
        // Create complex type property.
        ComplexTypePropertyUtils.create(Setup.TEST_CELL1, Setup.TEST_BOX1, collectionName, complexTypePropertyName,
                complexTypeName, "Edm.String", HttpStatus.SC_CREATED);

        // Recursive delete collection.
        deleteRecursive(collectionName, "true", HttpStatus.SC_NO_CONTENT);
    } finally {
        deleteRecursive(collectionName, "true", -1);
    }
}

@Test
public void checkStatusAuthenticationFailed() throws Exception {
    thrown.expect(ValidationJsonException.class);
    thrown.expect(MatcherUtil.validationMatcher(VCloudPluginResource.PARAMETER_API, "vcloud-login"));
    httpServer.stubFor(post(urlPathEqualTo("/api/sessions")).willReturn(aResponse().withStatus(HttpStatus.SC_FORBIDDEN)));
    httpServer.start();
    resource.checkStatus(subscriptionResource.getParametersNoCheck(subscription));
}

/**
 * 2つのCellを登録し、2回目のステータスコードを確認する。Cell名が重複でなければ201、重複であれば409であることを確認.
 * @param req DcRequestオブジェクト
 * @param method HTTPメソッド
 * @param url URL
 * @param name1 １つ目に作成するCellの名前
 * @param name2 ２つ目に作成するCellの名前
 */
public void cellCreateResCheck(PersoniumRequest req, String method, String url, String name1, String name2) {

    // 1回目
    req.header(HttpHeaders.AUTHORIZATION, BEARER_MASTER_TOKEN).addJsonBody("Name", name1);
    this.res = request(req);

    // Cell作成のレスポンスチェック
    // 201になることを確認
    assertEquals(HttpStatus.SC_CREATED, res.getStatusCode());

    // 2回目の要求
    PersoniumRequest req2 = null;
    if (method.equals(HttpMethod.POST)) {
        req2 = PersoniumRequest.post(url);
    }
    req2.header(HttpHeaders.AUTHORIZATION, BEARER_MASTER_TOKEN).addJsonBody("Name", name2);
    PersoniumResponse resConflict = request(req2);

    // Cell作成のレスポンスチェック
    try {
        if (name1.equals(name2)) {
            // 409であることを確認
            assertEquals(HttpStatus.SC_CONFLICT, resConflict.getStatusCode());
            // レスポンスボディのチェック
            checkErrorResponse(resConflict.bodyAsJson(),
                    PersoniumCoreException.OData.ENTITY_ALREADY_EXISTS.getCode());
        } else {
            // 201であることを確認
            assertEquals(HttpStatus.SC_CREATED, resConflict.getStatusCode());
        }
    } finally {
        cellDelete(resConflict);
    }
}

/**
 * Cell取得した場合にatomフォーマットでレスポンスが返却されること. $format → atom Accept → application/atom+xml
 */
@Test
public final void ＄formatがatomでCell取得した場合にatomフォーマットでレスポンスが返却されること() {
    String url = getUrl(this.cellId);
    // $format atom
    // Acceptヘッダ なし
    PersoniumResponse res = this.restGet(url + "?" + QUERY_FORMAT_ATOM);

    assertEquals(HttpStatus.SC_OK, res.getStatusCode());
    this.responseHeaderMap.put(HTTP.CONTENT_TYPE, MediaType.APPLICATION_ATOM_XML);
    this.checkHeaders(res);
    // Etagのチェック
    assertEquals(1, res.getResponseHeaders(HttpHeaders.ETAG).length);
    res.bodyAsXml();
}

@DELETE
@Path("/{albumId}")
@Produces(MediaType.APPLICATION_JSON)
@Secured
public Response deleteAlbum(@PathParam("albumId") Long albumId) {
    List<Long> albumList = new ArrayList();
    albumList.add(albumId);
    _facade.deleteAlbums(albumList, true);

    return Response.status(HttpStatus.SC_OK).build();
}

/**
 * Create webdav collection.
 * @param cellName Cell name
 * @param boxName Box name
 * @param path Path
 * @return API response
 */
public TResponse createWebdavCollection(String cellName, String boxName, String path) {
    return Http.request("box/mkcol-normal-fullpath.txt")
            .with("cell", cellName)
            .with("box", boxName)
            .with("path", path)
            .with("token", AbstractCase.BEARER_MASTER_TOKEN)
            .returns().debug().statusCode(HttpStatus.SC_CREATED);
}

/**
 * Linkを登録する.
 */
private void createLink() {
    Http.request("links-create.txt")
            .with("token", AbstractCase.MASTER_TOKEN_NAME)
            .with("cellName", CELL_NAME)
            .with("entitySet", ENTITY_SET_BOX)
            .with("key", KEY)
            .with("navProp", NAV_PROP_ROLE)
            .with("uri", roleUri).returns()
            .statusCode(HttpStatus.SC_NO_CONTENT);
}

/**
 * Error test.
 * Delete box linked with relation.
 */
@SuppressWarnings("unchecked")
@Test
public final void error_delete_box_linked_with_relation() {
    String token = AbstractCase.MASTER_TOKEN_NAME;
    String boxName = "boxhuga";
    String relationName = "relationhuge";

    try {
        // Boxの作成
        BoxUtils.create(cellName, boxName, token, HttpStatus.SC_CREATED);

        // 準備。Relation、ロール作ってリンクさせる。
        JSONObject body = new JSONObject();
        body.put("Name", relationName);
        body.put("_Box.Name", null);
        RelationUtils.create(cellName, token, body, HttpStatus.SC_CREATED);
        LinksUtils.createLinks(cellName, Relation.EDM_TYPE_NAME, relationName, null,
                Box.EDM_TYPE_NAME, boxName, null, token, HttpStatus.SC_NO_CONTENT);

        // 削除できないことの確認
        BoxUtils.delete(cellName, token, boxName, HttpStatus.SC_CONFLICT);

        // リンクを解除し、削除できるようになることの確認
        LinksUtils.deleteLinks(cellName, Relation.EDM_TYPE_NAME, relationName, boxName,
                Box.EDM_TYPE_NAME, boxName, null, token, HttpStatus.SC_NO_CONTENT);
        BoxUtils.delete(cellName, token, boxName, HttpStatus.SC_NO_CONTENT);
    } finally {
        LinksUtils.deleteLinks(cellName, Relation.EDM_TYPE_NAME, relationName, boxName,
                Box.EDM_TYPE_NAME, boxName, null, token, -1);
        BoxUtils.delete(cellName, token, boxName, -1);
        RelationUtils.delete(cellName, token, relationName, null, -1);
    }
}