@Test
@DirtiesContext
public void testHasParentStoryConflict_differentProduct() {
Product product = new Product();
Product targetProduct = new Product();
Project project = new Project();
Project targetProject = new Project();
Story parentStory = new Story();
Story story = new Story();
targetProject.setParent(targetProduct);
project.setParent(product);
parentStory.setBacklog(project);
story.setBacklog(project);
story.setParent(parentStory);
expect(this.backlogBusiness.getParentProduct(targetProject)).andReturn(targetProduct);
expect(this.backlogBusiness.getParentProduct(project)).andReturn(product);
replayAll();
assertTrue(this.testable.hasParentStoryConflict(story, targetProject));
verifyAll();
}
// Call when not tracking state
@Test
public void testRunNotTracking() {
sLogger.setWriter(new StringWriter());
sLogger.start();
assertTrue(sLogger.isRunning());
ArrayList<StateGroup> grouplist = new ArrayList<>();
grouplist.add(group);
resetAll();
expect(mockTracker.isTrackingState()).andReturn(false).anyTimes();
expect(mockTracker.getIoSet()).andReturn(ioSet).anyTimes();
expect(mockTracker.getStateList()).andReturn(grouplist).anyTimes();
replayAll();
Thread t =
new Thread(
new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
sLogger.stop();
}
});
t.start();
sLogger.run();
}
@Test
@DirtiesContext
public void testChangeBacklog_moveToAnotherProduct_noConflict() {
replayAll();
messages = testable.checkChangeBacklog(story_12, new Product());
verifyAll();
assertNumberOfMessages(messages, 0);
}
@Test
public void addCommandTest() {
Command cmd = createMock(MoveCommand.class);
Drone drone = Drone.getInstance();
ThreadCmd tc = new ThreadCmd(drone);
expect(cmd.isUnique()).andReturn(true);
replayAll();
tc.addCommand(cmd);
verifyAll();
}
@Test
public void testOpslaan() throws Exception {
PedicureSalon pedicureSalon = new PedicureSalon();
bedrijfClient.opslaanPedicureSalon(pedicureSalon);
expectLastCall();
replayAll();
bedrijfService.opslaan(pedicureSalon);
verifyAll();
}
@Test
@DirtiesContext
public void testChangeBacklog_moveToAnotherProduct_withConflict() {
Product another = new Product();
expect(backlogBusiness.getParentProduct(story_23.getBacklog())).andReturn(product);
expect(backlogBusiness.getParentProduct(another)).andReturn(another);
replayAll();
messages = testable.checkChangeBacklog(story_23, another);
verifyAll();
assertNumberOfMessages(messages, 1);
}
@Test
public void testFind() throws Exception {
expect(client.get("products/70")).andReturn(request);
expect(request.code()).andReturn(200);
expect(request.body()).andReturn(productResponse(true));
replayAll();
Response<Product> response = Product._find(client, 70);
Product product = response.getResource();
assertEquals("Wrong product name", "Basic", product.getName());
assertEquals("Wrong product handle", "basic", product.getHandle());
}
@Test
public void testZoekOpApiCode() throws Exception {
String apiCode = "apiCodeee";
PedicureSalon pedicureSalon = new PedicureSalon();
expect(bedrijfClient.zoekOpApiCode(apiCode)).andReturn(pedicureSalon);
replayAll();
assertEquals(pedicureSalon, bedrijfService.zoekOpApiCode(apiCode));
verifyAll();
}
@Test
@DirtiesContext
public void testChangeBacklog_moveToDifferentBranch() {
expect(backlogBusiness.getParentProduct(story_33.getBacklog())).andReturn(product);
expect(backlogBusiness.getParentProduct(project1)).andReturn(product);
replayAll();
messages = testable.checkChangeBacklog(story_33, project1);
verifyAll();
assertNumberOfMessages(messages, 1);
assertMessagesContain(
messages, StoryHierarchyIntegrityViolationType.PARENT_IN_WRONG_BRANCH, story_33, story_22);
}
@Test
@DirtiesContext
public void testChangeParent_moveToDifferentBranch() {
// 41 -> 22
replayAll();
messages = testable.checkChangeParentStory(story_41, story_22);
verifyAll();
assertNumberOfMessages(messages, 1);
assertMessagesContain(
messages,
StoryHierarchyIntegrityViolationType.TARGET_PARENT_IN_WRONG_BRANCH,
story_41,
story_22);
}
@Test
@DirtiesContext
public void testChangeParent_moveUnderIterationStory() {
// 32 -> 41
replayAll();
messages = testable.checkChangeParentStory(story_32, story_41);
verifyAll();
assertNumberOfMessages(messages, 1);
assertMessagesContain(
messages,
StoryHierarchyIntegrityViolationType.TARGET_PARENT_IN_ITERATION,
story_32,
story_41);
}
@Test
@DirtiesContext
public void testChangeBacklog_hasChildren_movingToIteration() {
expect(backlogBusiness.getParentProduct(story_31.getBacklog())).andReturn(product);
expect(backlogBusiness.getParentProduct(iteration)).andReturn(product);
replayAll();
messages = testable.checkChangeBacklog(story_31, iteration);
verifyAll();
assertNumberOfMessages(messages, 1);
assertMessagesContain(
messages,
StoryHierarchyIntegrityViolationType.MOVE_TO_ITERATION_HAS_CHILDREN,
story_31,
null);
}
@Test
@DirtiesContext
public void testChangeBacklog_moveToProduct_parentInProject() {
expect(backlogBusiness.getParentProduct(story_41.getBacklog())).andReturn(product);
expect(backlogBusiness.getParentProduct(product)).andReturn(product);
replayAll();
messages = testable.checkChangeBacklog(story_41, product);
verifyAll();
assertNumberOfMessages(messages, 1);
assertMessagesContain(
messages,
StoryHierarchyIntegrityViolationType.PARENT_DEEPER_IN_HIERARCHY,
story_41,
story_31);
}
@Test
@DirtiesContext
public void testChangeParent_moveProductStoryUnderProjectStory() {
// 23 -> 22
// 34 vaihtaa branchia
replayAll();
messages = testable.checkChangeParentStory(story_23, story_22);
verifyAll();
assertNumberOfMessages(messages, 1);
assertMessagesContain(
messages,
StoryHierarchyIntegrityViolationType.TARGET_PARENT_DEEPER_IN_HIERARCHY,
story_23,
story_22);
}
@Test
@DirtiesContext
public void testChangeBacklog_hasChildren_notUnderTargetBacklog() {
expect(backlogBusiness.getParentProduct(story_21.getBacklog())).andReturn(product);
expect(backlogBusiness.getParentProduct(project2)).andReturn(product);
replayAll();
messages = testable.checkChangeBacklog(story_21, project2);
verifyAll();
assertNumberOfMessages(messages, 3);
assertMessagesContain(
messages, StoryHierarchyIntegrityViolationType.CHILD_IN_WRONG_BRANCH, story_21, story_31);
assertMessagesContain(
messages, StoryHierarchyIntegrityViolationType.CHILD_IN_WRONG_BRANCH, story_31, story_41);
assertMessagesContain(
messages, StoryHierarchyIntegrityViolationType.CHILD_IN_WRONG_BRANCH, story_21, story_32);
}
@Test
public void wifiConnectThreadStartTest() throws Exception {
WiFiConnection wifi = createMock(WiFiConnection.class);
NavData navData = new NavData();
PacketDemo packetDemo = new PacketDemo();
mockStatic(Tools.class);
wifi.connect();
expectLastCall();
expect(Tools.get_state_bit(navData.drone_state, 6)).andReturn(false);
wifi.sendAtCommand("AT*CONFIG=#SEQ#,\"custom:session_id\",\"ca0000d1\"");
expectLastCall();
expect(Tools.get_state_bit(navData.drone_state, 6)).andReturn(true);
wifi.sendAtCommand("AT*CTRL=#SEQ#,5,0");
expectLastCall();
expect(wifi.isRunning()).andReturn(true).anyTimes();
// wifi.setRunning(false);
// expectLastCall();
replayAll();
Drone drone = Drone.getInstance();
Whitebox.setInternalState(drone, "wifi", wifi);
Whitebox.setInternalState(navData, "drone_state", 0);
Whitebox.setInternalState(drone, "navData", navData);
drone.connect();
// Thread.sleep(500);
ThreadNavData threadNavData = Whitebox.getInternalState(drone, "threadNavData");
ThreadCmd threadCmd = Whitebox.getInternalState(drone, "threadCmd");
// threadNavData.stop();
assertFalse("Drone.threadCmd is in state NEW", threadCmd.getState() == Thread.State.NEW);
assertFalse(
"Drone.threadCmd is in state TERMINATED", threadCmd.getState() == Thread.State.TERMINATED);
assertFalse(
"Drone.threadNavData is in state NEW", threadNavData.getState() == Thread.State.NEW);
assertFalse(
"Drone.threadNavData is in state TERMINATED",
threadNavData.getState() == Thread.State.TERMINATED);
threadCmd.stop();
threadNavData.stop();
verifyAll();
}
@Test
@DirtiesContext
public void testChangeParent_moveBranchUnderAnother() {
// 22 -> 31
// 2 virhettä, 22->31, 33 -> 31
replayAll();
messages = testable.checkChangeParentStory(story_22, story_31);
verifyAll();
assertNumberOfMessages(messages, 2);
assertMessagesContain(
messages,
StoryHierarchyIntegrityViolationType.TARGET_PARENT_IN_WRONG_BRANCH,
story_22,
story_31);
assertMessagesContain(
messages,
StoryHierarchyIntegrityViolationType.TARGET_PARENT_IN_WRONG_BRANCH,
story_22,
story_33);
}
@Test
@DirtiesContext
public void testHasParentStoryConflict_toIteration() {
Product product = new Product();
Project project = new Project();
Iteration iteration = new Iteration();
Story parentStory = new Story();
Story story = new Story();
iteration.setParent(project);
project.setParent(product);
parentStory.setBacklog(project);
story.setBacklog(project);
story.setParent(parentStory);
expect(this.backlogBusiness.getParentProduct(iteration)).andReturn(product);
expect(this.backlogBusiness.getParentProduct(project)).andReturn(product);
replayAll();
assertFalse(this.testable.hasParentStoryConflict(story, iteration));
verifyAll();
}