Java 播放测试-数据持久性问题-使用GET时发布的数据不可用

我正在处理一个基于Play 2.0的RESTful API实现，当我尝试运行测试用例（CRUD操作）时，我发现在后续测试用例中执行GET操作时，发布的请求内容（成功的201响应）不可用

请看一下我的JUnit测试类-

public class TagTest {

public static FakeApplication app;

private static String AUTH_HEADER = "Authorization";
private static String AUTH_VALUE = "Basic a25paadsfdfasdfdsfasdmeSQxMjM=";
private static int tagId = 0;

private static Map<String, String> postDataMap = new HashMap<String, String>();
private static Map<String, String> updateDataMap = new HashMap<String, String>();
private static String searchText = null;

@BeforeClass
public static void setUpBeforeClass() {
    // Set up new FakeApplication before running any tests
    app = Helpers.fakeApplication();
    Helpers.start(app);
    postDataMap.put("text", "Created");
    updateDataMap.put("text", "Updated");
    searchText = "Date"; // case insensitive substring pattern for "Updated"
}

@Test
public void createTagTest() {
    app = Helpers.fakeApplication();

    running(fakeApplication(), new Runnable() {
        public void run() {
            JsonNode json = Json.toJson(postDataMap);

            FakeRequest request=new FakeRequest().withJsonBody(json);
            Result result = callAction(controllers.routes.ref.Application.createTag(),request.withHeader(TagTest.AUTH_HEADER, TagTest.AUTH_VALUE));

            Map<String, String> headerMap = Helpers.headers(result);
            String location = headerMap.get(Helpers.LOCATION);
            String tagIdStr = location.replace("/tags/","");
            try {
                tagId = Integer.parseInt(tagIdStr);
                assertThat(status(result)).isEqualTo(Helpers.CREATED);
                System.out.println("Tag Id : "+tagId+" Location : "+headerMap.get(Helpers.LOCATION)); // Here I'm getting resource URI from API which means it is successful run

            } catch (NumberFormatException e) {
                System.out.println("Inside NumberFormatException");
                e.printStackTrace();
                assertThat(0).isEqualTo(1);
            }
            System.out.println("createTagTest is successful");
        }
    });
}

@Test
public void getTagTest() {
    app = Helpers.fakeApplication();

    running(fakeApplication(), new Runnable() {
        public void run() {
            FakeRequest request = new FakeRequest();
            Result result = callAction(controllers.routes.ref.Application.getTag(tagId), request.withHeader(TagTest.AUTH_HEADER, TagTest.AUTH_VALUE));
            String content = contentAsString(result);
            if(content.length()==0) {
                assertThat(status(result)).isEqualTo(Helpers.NO_CONTENT);
            } else {
                assertThat(status(result)).isEqualTo(Helpers.OK);
            }
            System.out.println("getTagTest is successful");
        }
    });
}

@Test
public void updateTagTest() {
    app = Helpers.fakeApplication();

    running(fakeApplication(), new Runnable(){
        public void run() {
            JsonNode json = Json.toJson(updateDataMap);
            FakeRequest request = new FakeRequest().withJsonBody(json);
            Result result = callAction(controllers.routes.ref.Application.updateTag(tagId), 
                                        request.withHeader(TagTest.AUTH_HEADER, TagTest.AUTH_VALUE));
            assertThat(status(result)).isEqualTo(Helpers.OK);
            System.out.println("updateTagTest is successful");
        }
    });
}

@Test
public void getAllTagsTest() {
    app = Helpers.fakeApplication();

    running(fakeApplication(), new Runnable() {
        public void run() {
            FakeRequest request = new FakeRequest();
            Result result = callAction(controllers.routes.ref.Application.getAllTags(null), request.withHeader(TagTest.AUTH_HEADER, TagTest.AUTH_VALUE));
            String content = contentAsString(result);
            System.out.println(content);
            if(content.length()==0) {
                System.out.println("No content");
                assertThat(status(result)).isEqualTo(Helpers.NO_CONTENT);
            } else {
                System.out.println("Content");
                assertThat(status(result)).isEqualTo(Helpers.OK);
            }
            System.out.println("getAllTagsTest is successful");
        }
    });
}

@Test
public void getTagsByTextTest() {
    app = Helpers.fakeApplication();

    running(fakeApplication(), new Runnable() {
        public void run() {
            FakeRequest request = new FakeRequest();
            Result result = callAction(controllers.routes.ref.Application.getAllTags(searchText), request.withHeader(TagTest.AUTH_HEADER, TagTest.AUTH_VALUE));
            String content = contentAsString(result);
            if(content.length()==0) {
                assertThat(status(result)).isEqualTo(Helpers.NO_CONTENT);
            } else {
                assertThat(status(result)).isEqualTo(Helpers.OK);
            }
            System.out.println("getAllTagsByTextTest is successful");
        }
    });
}

@Test
public void deleteTagTest() {
    app = Helpers.fakeApplication();

    running(fakeApplication(), new Runnable() {
        public void run() {
            FakeRequest request = new FakeRequest();
            Result result = callAction(controllers.routes.ref.Application.deleteTag(tagId), request.withHeader(TagTest.AUTH_HEADER, TagTest.AUTH_VALUE));
            assertThat(status(result)).isEqualTo(Helpers.OK);
            System.out.println("deleteTagTest is successful");
        }
    });
}

@AfterClass
public static void tearDownAfterClass() {
    // Stop FakeApplication after all tests complete
    Helpers.stop(app);
}
}

公共类标记测试{
公共静态伪造应用程序；
私有静态字符串AUTH_HEADER=“Authorization”；
私有静态字符串AUTH_VALUE=“Basic a25paadsfdffasdfdsfasdmesqxmjm=”；
私有静态int-tagId=0；
私有静态映射postDataMap=newhashmap（）；
私有静态映射updateDataMap=newHashMap（）；
私有静态字符串searchText=null；
@课前
公共静态无效SetupForeClass（）{
//在运行任何测试之前设置新的FakeApplication
app=Helpers.fakeApplication（）；
Helpers.start（应用程序）；
postDataMap.put（“文本”、“已创建”）；
updateDataMap.put（“文本”、“更新”）；
searchText=“Date”；//用于“Updated”的不区分大小写的子字符串模式
}
@试验
public void createTagTest（）{
app=Helpers.fakeApplication（）；
正在运行（fakeApplication（），new Runnable（））{
公开募捐{
JsonNode json=json.toJson（postDataMap）；
FakereRequest=new FakereRequest（），带JSONBody（json）；
结果=调用操作（controllers.routes.ref.Application.createTag（），request.withHeader（TagTest.AUTH_HEADER，TagTest.AUTH_VALUE））；
Map headerMap=Helpers.headers（结果）；
字符串位置=headerMap.get（Helpers.location）；
字符串tagIdStr=location.replace（“/tags/”，“”）；
试一试{
tagId=Integer.parseInt（tagIdStr）；
assertThat（status（result））.isEqualTo（Helpers.CREATED）；
System.out.println（“标记Id:+tagId+”位置：“+headerMap.get（Helpers.Location））；//这里我从API获取资源URI，这意味着它已成功运行
}捕获（数字格式）{
System.out.println（“内部编号格式异常”）；
e、 printStackTrace（）；
认定（0）、等质量（1）；
}
System.out.println（“createTagTest成功”）；
}
});
}
@试验
public void getTagTest（）{
app=Helpers.fakeApplication（）；
正在运行（fakeApplication（），new Runnable（））{
公开募捐{
FakeRequest请求=新的FakeRequest（）；
结果=调用操作（controllers.routes.ref.Application.getTag（tagId），request.withHeader（TagTest.AUTH_HEADER，TagTest.AUTH_VALUE））；
字符串内容=contentAsString（结果）；
if（content.length（）==0）{
assertThat（status（result））.isEqualTo（Helpers.NO_内容）；
}否则{
assertThat（status（result））.isEqualTo（Helpers.OK）；
}
System.out.println（“getTagTest成功”）；
}
});
}
@试验
public void updateTagTest（）{
app=Helpers.fakeApplication（）；
正在运行（fakeApplication（），new Runnable（））{
公开募捐{
JsonNode json=json.toJson（updateDataMap）；
FakereRequest=new FakereRequest（），带JSONBody（json）；
结果=调用操作（controllers.routes.ref.Application.updateTag（tagId），
request.withHeader（TagTest.AUTH_HEADER，TagTest.AUTH_VALUE））；
assertThat（status（result））.isEqualTo（Helpers.OK）；
System.out.println（“更新测试成功”）；
}
});
}
@试验
public void getAllTagsTest（）{
app=Helpers.fakeApplication（）；
正在运行（fakeApplication（），new Runnable（））{
公开募捐{
FakeRequest请求=新的FakeRequest（）；
Result-Result=callAction（controllers.routes.ref.Application.getAllTags（null），request.withHeader（TagTest.AUTH_HEADER，TagTest.AUTH_VALUE））；
字符串内容=contentAsString（结果）；
系统输出打印项次（内容）；
if（content.length（）==0）{
System.out.println（“无内容”）；
assertThat（status（result））.isEqualTo（Helpers.NO_内容）；
}否则{
System.out.println（“内容”）；
assertThat（status（result））.isEqualTo（Helpers.OK）；
}
System.out.println（“getAllTagsTest成功”）；
}
});
}
@试验
public void getTagsByTextTest（）{
app=Helpers.fakeApplication（）；
正在运行（fakeApplication（），new Runnable（））{
公开募捐{
FakeRequest请求=新的FakeRequest（）；
结果=调用操作（controllers.routes.ref.Application.getAllTags（searchText），request.withHeader（TagTest.AUTH_HEADER，TagTest.AUTH_VALUE））；
字符串内容=contentAsString（结果）；
if（content.length（）==0）{
assertThat（status（result））.isEqualTo（Helpers.NO_内容）；
}否则{
assertThat（status（result））.isEqualTo（Helpers.OK）；
}
System.out.println（“getAllTagsByTextTest成功”）；
}
});
}
@试验
公共无效deleteTagTest（）{
app=Helpers.fakeApplication（）；
正在运行（fakeApplication（），new Runnable（））{
公开募捐{
FakeRequest请求=新的FakeRequest（）；
结果=调用操作（controllers.routes.ref.Application.deleteTag（tagId），request.withHeader（TagTest.AUTH_HEADER，TagTest.AUTH_VALUE））；
assertThat（status（result））.isEqualTo（Helpers.OK）；
System.out.println（“deleteTagTest成功”）；
}
});
}
@下课
公共静态void tearDownAfterClass（）{
//所有测试完成后停止伪造应用程序
Helpers.stop（应用程序）；
}
}

当我运行测试时，创建了标记，但在尝试执行GET/tags/1时，在随后的测试中没有拾取该标记，因此没有内容

请扔些灯给我