PositionServiceTest.java

package service;

import api.v1.*;
import mapper.CustomerMapper;
import mapper.PositionMapper;
import models.CustomerModel;
import models.OrderModel;
import models.PositionModel;
import models.PositionTagModel;
import org.junit.Test;
import util.InMemoryDbTest;

import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import static org.junit.Assert.*;

public class PositionServiceTest extends InMemoryDbTest {


  @Test
  public void testIsDeletable() {
    PositionService service = new PositionService(fakeUser);
    //List<PositionModel> positions = service.getPositionsForCustomer(3L);
    PositionModel p1 = service.findByName("Ekofisk");
    assertFalse("Ekofisk is unexpectedly deletable", p1.isDeletable);

    PositionModel p2 = service.findByName("Hewett");
    assertTrue("Hewett is unexpectedly not deletable", service.isDeletable(p2.id));

    OrderService orderService = new OrderService(fakeUser);
    OrderModel order = orderService.getByMetref("ordertestdeleted");
    assertNotNull(order.deleted);
    assertNotNull("Bestilling ordertestdeleted har ingen posisjon ", order.position);
    assertTrue("ordertestdeleted.position is unexpectedly not deletable", order.position.isDeletable);
  }

  @Test
  public void testListAll() {
    PositionService service = new PositionService(fakeUser);
    List<PositionModel> positions = service.findAll();
    assertNotNull("positions null", positions);
    assertEquals("positionlist", 14, positions.size());
  }

  @Test
  public void testGetCustomerPositions() {
    PositionService service = new PositionService(fakeUser);
    List<PositionModel> positions = service.getPositionsForCustomer(3L);
    assertNotNull("positions null", positions);
    assertEquals("positionlist", 3, positions.size());

    assertEquals("p1.alias", "Echofish", positions.get(0).alias);
    assertEquals("p2.alias", "Gullfaks", positions.get(1).alias);

    assertEquals("Ekofisk tags", 3, positions.get(0).tags.size());
  }

  @Test
  public void testSearchName() {
    PositionService service = new PositionService(fakeUser);
    PositionSearch searchParams = new PositionSearch();
    searchParams.position_name = "Gull";
    List<PositionModel> positions = service.search(searchParams);
    assertNotNull("positions null", positions);
    assertEquals("positionlist", 1, positions.size());
    assertEquals("name ", "Gullfaks", positions.get(0).name);
    assertNull("alias not null", positions.get(0).alias);
    assertEquals("Gullfaks tags", 3, positions.get(0).tags.size());

  }

  @Test
  public void testSearchDistance() {
    PositionService service = new PositionService(fakeUser);
    PositionSearch searchParams = new PositionSearch();
    searchParams.position_name = "Veslefrikk";
    searchParams.radius = 50.0;
    List<PositionModel> positions = service.search(searchParams);
    assertNotNull("positions null", positions);
    assertEquals("positionlist", 7, positions.size());

  }

  @Test
  public void testSearchBoundingBox() {
    PositionService service = new PositionService(fakeUser);
    PositionSearch searchParams = new PositionSearch();
    searchParams.searchArea = new BoundingBox(55.7, 3.6, 57.0, 4);
    List<PositionModel> positions = service.search(searchParams);
    assertNotNull("positions null", positions);
    assertEquals("positionlist", 3, positions.size());
  }

  @Test
  public void testSearchTags() {
    PositionService service = new PositionService(fakeUser);
    PositionSearch searchParams = new PositionSearch();
    searchParams.tags = new PositionTag[2];
    searchParams.tags[0] = new PositionTag(0L, "United Kingdom");
    searchParams.tags[1] = new PositionTag(0L, "Platform");
    List<PositionModel> positions = service.search(searchParams);
    assertNotNull("positions null", positions);
    assertEquals("positionlist", 9, positions.size());

  }

  @Test
  public void testAddPositionTag() {
    PositionService service = new PositionService(fakeUser);
    List<PositionModel> positions = service.getPositionsForCustomer(3L);
    PositionModel positionModel = positions.get(0);
    Position position = new PositionMapper().mapToApi(positionModel);

    position.tags = new PositionTag[position.tags.length + 1];
    int i = 0;
    for (Iterator<PositionTagModel> itr = positionModel.tags.iterator(); itr.hasNext(); i++) {
      PositionTagModel positionTagModel = itr.next();
      position.tags[i] = new PositionTag(positionTagModel.id, positionTagModel.name);
    }
    position.tags[position.tags.length - 1] = new PositionTag(0L, "Dummy");
    PositionModel p2 = service.createOrUpdate(position);

    assertEquals("Tags size", positionModel.tags.size() + 1, p2.tags.size());
  }

  @Test
  public void testModifyPositionTags() {

    PositionService service = new PositionService(fakeUser);
    List<PositionModel> positions = service.getPositionsForCustomer(3L);
    PositionModel positionModel = positions.get(0);
    Position position = new PositionMapper().mapToApi(positionModel);

    position.tags = new PositionTag[position.tags.length];
    int i = 0;
    for (Iterator<PositionTagModel> itr = positionModel.tags.iterator(); itr.hasNext(); i++) {
      PositionTagModel positionTagModel = itr.next();
      position.tags[i] = new PositionTag(positionTagModel.id, positionTagModel.name);
    }

    position.tags[0] = new PositionTag(0L, "ZZZ");
    PositionModel p2 = service.createOrUpdate(position);

    assertEquals("Tags size", positionModel.tags.size(), p2.tags.size());

    // Note that createOrUpdate does not sort the tags.  When fetching the
    // position from the database the tag order will be sorted

    assertEquals("T1", "ZZZ", p2.tags.get(0).name);
    assertEquals("T2", "Nordsjøen", p2.tags.get(1).name);
    assertEquals("T3", "Norge", p2.tags.get(2).name);

    PositionModel p3 = service.getById(p2.id);

    assertEquals("T1", "Nordsjøen", p3.tags.get(0).name);
    assertEquals("T2", "Norge", p3.tags.get(1).name);
    assertEquals("T3", "ZZZ", p3.tags.get(2).name);


  }

  @Test
  public void testDeletePositionTags() {

    PositionService service = new PositionService(fakeUser);
    List<PositionModel> positions = service.getPositionsForCustomer(3L);
    PositionModel positionModel = positions.get(0);

    Position position = new PositionMapper().mapToApi(positionModel);

    // remove the last tag by iterating up to, but not including
    // final element
    position.tags = new PositionTag[position.tags.length - 1];
    int i = 0;
    for (Iterator<PositionTagModel> itr = positionModel.tags.iterator(); i < position.tags.length; i++) {
      PositionTagModel positionTagModel = itr.next();
      position.tags[i] = new PositionTag(positionTagModel.id, positionTagModel.name);
    }

    assertEquals("T1", "Atlanterhavet", position.tags[0].name);
    assertEquals("T2", "Nordsjøen", position.tags[1].name);

    PositionModel p2 = service.createOrUpdate(position);

    assertEquals("Tags size", positionModel.tags.size() - 1, p2.tags.size());

    PositionTagModel[] p2Tags = p2.tags.toArray(new PositionTagModel[positionModel.tags.size()]);
    assertEquals("T1", "Atlanterhavet", p2Tags[0].name);
    assertEquals("T2", "Nordsjøen", p2Tags[1].name);
  }


  @Test
  public void testDeletePosition() {

    PositionService service = new PositionService(fakeUser);
    PositionModel p = service.findByName("Vulcan");
    assertNotNull("not null", p);
    assertTrue("is not deletable", p.isDeletable);
    p = service.deletePosition(p);
    assertNotNull(p.deleted);
    assertNotNull(p.deletedBy);
  }


  @Test
  public void testDeleteAndCreatePosition() {

    PositionService service = new PositionService(fakeUser);
    PositionModel p = service.findByName("Vulcan");
    p = service.deletePosition(p);
    assertNotNull("deleted is null", p.deleted);
    assertNotNull("deletedBy is null", p.deletedBy);
    Position apiPos = new PositionMapper().mapToApi(p);
    apiPos.id = null;
    p = service.createOrUpdate(apiPos);
    assertNull("deleted is not null", p.deleted);
    assertNull("deletedBy is not null", p.deletedBy);

  }

  @Test
  public void testMultiplePositionAliases() {

    long customerId = 1L;
    long positionId = 9L;

    OrderModel bestilling = createNewOrderReferencingExistingPositionWithAlias(customerId, positionId);

    PositionService service = new PositionService(fakeUser);

    List<PositionModel> positions = service.getPositionsForCustomer(customerId);

    assertNotNull("positions null", positions);
    assertEquals("positionlist", 4, positions.size());

    PositionModel p1 = positions.get(2);
    PositionModel p2 = positions.get(3);

    assertEquals("p1.id", positionId, (long) p1.id);
    assertEquals("p2.id", positionId, (long) p2.id);
    assertEquals("p1.name", "Huldra", p1.name);
    assertEquals("p2.name", "Huldra", p2.name);
    // det originale position objektet har ikke noe alias
    assertNull("p1.alias", p1.alias);
    assertEquals("p2.alias", "Huldra_alias", p2.alias);

  }

  private OrderModel createNewOrderReferencingExistingPositionWithAlias(Long customerId, Long positionId) {

    Order aOrder = new Order();

    aOrder.customer_email = "test@example.com";
    aOrder.customer_name = "Test";
    aOrder.customer_phone = "123";

    CustomerModel customerModel = new CustomerService(fakeUser).getById(customerId);
    Customer customer = new CustomerMapper().mapToApi(customerModel);
    aOrder.customer = customer;

    aOrder.custref_po_calloff = "32123";
    aOrder.met_ref = "111222";

    aOrder.start_date1 = new Date();
    aOrder.start_termin1 = 3;

    aOrder.end_date1 = new Date();
    aOrder.end_termin1 = 21;

    aOrder.info_for_meteorologist = "Bla bla";
    aOrder.other_info = "More bla bla";

    for (int i = 0; i < aOrder.termins1.length; i++) {
      aOrder.termins1[i] = new Termin(i * 3, i % 3 == 0);
    }


    // Hent eksisterende posisjon
    PositionModel positionModel = new PositionService(fakeUser).getById(positionId);
    Position position = new PositionMapper().mapToApi(positionModel);
    // referer til posisjonen i bestillingen
    aOrder.position = position;

    // tilordne et alias på posisjonen
    aOrder.position_name = position.name + "_alias";

    // ingen distribusjon
    aOrder.recipients = new ArrayList<>();

    // opprett bestillingen
    OrderModel order = new OrderService(fakeUser).createOrUpdate(aOrder);

    return order;
  }


}