@Before
    public void standUp() throws EntityNotFoundException, UnprocessableEntityException {
      lb = new LoadBalancer();
      lbRepository = mock(LoadBalancerRepository.class);
      lbService = new LoadBalancerServiceImpl();
      lbService.setLoadBalancerRepository(lbRepository);

      SslTermination sslTermination = new SslTermination();
      sslTermination.setIntermediateCertificate("iCert");
      sslTermination.setCertificate("cert");
      sslTermination.setPrivatekey("aKey");
      sslTermination.setEnabled(true);
      sslTermination.setSecurePort(445);
      sslTermination.setSecureTrafficOnly(false);

      lb.setSslTermination(sslTermination);
      lb.setStatus(LoadBalancerStatus.ACTIVE);

      defaultProtocol =
          new LoadBalancerProtocolObject(LoadBalancerProtocol.HTTP, "HTTP Protocol", 80, true);
      when(lbRepository.getByIdAndAccountId(Matchers.<Integer>any(), Matchers.<Integer>any()))
          .thenReturn(lb);
      //            when(lbRepository.testAndSetStatus(Matchers.<Integer>any(),
      // Matchers.<Integer>any(),Matchers.<LoadBalancerStatus>any(),
      // Matchers.<Boolean>any())).thenReturn(true);

    }
    @Test(expected = BadRequestException.class)
    public void shouldRejectUpdateProtocolIfUsingSslTermination() throws Exception {
      LoadBalancer loadBalancer = new LoadBalancer();
      loadBalancer.setProtocol(LoadBalancerProtocol.HTTPS);
      loadBalancer.setStatus(LoadBalancerStatus.ACTIVE);

      lbService.prepareForUpdate(loadBalancer);
    }
    @Test
    public void shouldSetStatusToBuildWhenStatusIsModified() {
      lb.setStatus(LoadBalancerStatus.ERROR);

      lbService.addDefaultValues(lb);

      Assert.assertEquals(LoadBalancerStatus.BUILD, lb.getStatus());
    }
    @Test(expected = BadRequestException.class)
    public void shouldFailWhenUpdatingPortToSSLPort() throws Exception {

      LoadBalancer loadBalancer = new LoadBalancer();
      loadBalancer.setStatus(LoadBalancerStatus.ACTIVE);
      loadBalancer.setPort(445);

      lbService.prepareForUpdate(loadBalancer);
    }
    @Test(expected = BadRequestException.class)
    public void shouldVerifySharedVipLbs() throws Exception {

      List<LoadBalancer> lbs = new ArrayList<LoadBalancer>();
      LoadBalancer loadBalancer = new LoadBalancer();
      loadBalancer.setId(3333);
      loadBalancer.setAccountId(55555);

      Set<LoadBalancerJoinVip> jvips = new HashSet<LoadBalancerJoinVip>();
      LoadBalancerJoinVip jvip = new LoadBalancerJoinVip();

      jvip.setVirtualIp(new VirtualIp());
      jvip.setId(new LoadBalancerJoinVip.Id(loadBalancer.getId(), 676));
      jvip.setLoadBalancer(lb);
      jvips.add(jvip);
      loadBalancer.setLoadBalancerJoinVipSet(jvips);

      List<LoadBalancer> sharedlbs = new ArrayList<LoadBalancer>();
      LoadBalancer sharedlb = new LoadBalancer();
      sharedlb.setId(9844);
      sharedlbs.add(sharedlb);
      when(virtualIpRepository.getLoadBalancersByVipId(Matchers.anyInt())).thenReturn(sharedlbs);

      lbs.add(loadBalancer);

      when(lbRepository.getById(Matchers.anyInt())).thenReturn(loadBalancer);
      List<LoadBalancer> newLbs;
      newLbs = lbService.reassignLoadBalancerHost(lbs);

      LoadBalancer newLb;
      newLb = newLbs.get(0);

      Assert.assertEquals((Object) 55555, newLb.getAccountId());
    }
    @Test
    public void shouldUpdateNodesStatusAndWeightsAppropriately() {
      Set<Node> nodes = new HashSet<Node>();
      Node node1 = new Node();
      Node node2 = new Node();
      Node node3 = new Node();

      node1.setCondition(NodeCondition.ENABLED);
      node2.setCondition(NodeCondition.DRAINING);
      node3.setCondition(NodeCondition.DISABLED);
      node1.setWeight(null);
      node2.setWeight(0);
      node3.setWeight(10);
      nodes.add(node1);
      nodes.add(node2);
      nodes.add(node3);
      lb.setNodes(nodes);

      lbService.addDefaultValues(lb);

      Assert.assertEquals(NodeStatus.ONLINE, node1.getStatus());
      Assert.assertEquals(NodeStatus.ONLINE, node2.getStatus());
      Assert.assertEquals(NodeStatus.ONLINE, node3.getStatus());

      Assert.assertEquals(1, node1.getWeight().intValue());
      Assert.assertEquals(0, node2.getWeight().intValue());
      Assert.assertEquals(10, node3.getWeight().intValue());
    }
    @Test
    public void shouldNotAddDefaultValuesWhenValuesAreSet() {
      lb.setAlgorithm(LoadBalancerAlgorithm.LEAST_CONNECTIONS);
      lb.setProtocol(LoadBalancerProtocol.IMAPv3);
      lb.setConnectionLogging(true);
      lb.setPort(1234);
      lb.setSessionPersistence(SessionPersistence.HTTP_COOKIE);

      lbService.addDefaultValues(lb);

      Assert.assertEquals(LoadBalancerAlgorithm.LEAST_CONNECTIONS, lb.getAlgorithm());
      Assert.assertEquals(LoadBalancerProtocol.IMAPv3, lb.getProtocol());
      Assert.assertTrue(lb.isConnectionLogging());
      Assert.assertEquals(1234, lb.getPort().intValue());
      Assert.assertEquals(SessionPersistence.HTTP_COOKIE, lb.getSessionPersistence());
    }
    @Test(expected = BadRequestException.class)
    public void shouldFailIfLbisSticky() throws Exception {
      when(lbRepository.getById(Matchers.<Integer>any())).thenReturn(lb);

      List<LoadBalancer> lbs = new ArrayList<LoadBalancer>();
      LoadBalancer loadBalancer = new LoadBalancer();
      loadBalancer.setId(3333);
      lb.setSticky(true);
      lbs.add(loadBalancer);

      List<LoadBalancer> newLbs;
      newLbs = lbService.reassignLoadBalancerHost(lbs);

      LoadBalancer newLb;
      newLb = newLbs.get(0);

      Assert.assertEquals((Object) 555555, newLb.getAccountId());
    }
    @Test
    public void shouldAddDefaultValuesWhenNoValuesAreSet() {
      lbService.addDefaultValues(lb);

      Assert.assertEquals(LoadBalancerAlgorithm.RANDOM, lb.getAlgorithm());
      Assert.assertEquals(LoadBalancerProtocol.HTTP, lb.getProtocol());
      Assert.assertFalse(lb.isConnectionLogging());
      Assert.assertEquals(defaultProtocol.getPort(), lb.getPort());
      Assert.assertEquals(SessionPersistence.NONE, lb.getSessionPersistence());
      Assert.assertEquals(LoadBalancerStatus.BUILD, lb.getStatus());
      Assert.assertEquals(false, lb.isHalfClosed());
    }
    @Before
    public void standUp()
        throws EntityNotFoundException, UnprocessableEntityException, ClusterStatusException,
            NoAvailableClusterException {
      lb = new LoadBalancer();
      lbRepository = mock(LoadBalancerRepository.class);
      lbService = new LoadBalancerServiceImpl();
      lbService.setLoadBalancerRepository(lbRepository);

      hostService = new HostServiceImpl();
      hostService.setLoadBalancerRepository(lbRepository);
      hostRepository = mock(HostRepository.class);
      hostService.setHostRepository(hostRepository);

      clusterService = new ClusterServiceImpl();
      clusterService.setLoadBalancerRepository(lbRepository);
      clusterRepository = mock(ClusterRepository.class);
      clusterService.setClusterRepository(clusterRepository);

      virtualIpRepository = mock(VirtualIpRepository.class);

      loadBalancerStatusHistoryRepository = mock(LoadBalancerStatusHistoryRepository.class);
      loadBalancerStatusHistoryService = new LoadBalancerStatusHistoryServiceImpl();
      loadBalancerStatusHistoryService.setLoadBalancerStatusHistoryRepository(
          loadBalancerStatusHistoryRepository);

      hostService.setClusterRepository(clusterRepository);
      //            lbService.setHostService(hostService);
      //            lbService.setLoadBalancerStatusHistoryService(loadBalancerStatusHistoryService);
      lbService.setVirtualIpRepository(virtualIpRepository);

      lb.setStatus(LoadBalancerStatus.ACTIVE);

      lb.setAccountId(555555);
      lb.setId(3333);
      lb.setPort(33);
      lb.setProtocol(LoadBalancerProtocol.HTTP);

      Host host = new Host();
      host.setId(2);
      host.setHostStatus(HostStatus.ACTIVE);

      Cluster cluster = new Cluster();
      cluster.setId(3);

      lb.setHost(host);

      when(hostRepository.getById(Matchers.<Integer>any())).thenReturn(host);
      when(hostRepository.getDefaultActiveHost(Matchers.<Integer>any())).thenReturn(host);
      when(clusterRepository.getActiveCluster(null, false)).thenReturn(cluster);
      when(hostService.getById(Matchers.<Integer>any())).thenReturn(host);
      when(loadBalancerStatusHistoryRepository.save(
              Matchers.<LoadBalancerStatusHistory>anyObject()))
          .thenReturn(new LoadBalancerStatusHistory());

      //            when(loadBalancerStatusHistoryService.save(lb.getAccountId(), lb.getId(),
      // status);)
      //            when(lbRepository.testAndSetStatus(Matchers.<Integer>any(),
      // Matchers.<Integer>any(),Matchers.<LoadBalancerStatus>any(),
      // Matchers.<Boolean>any())).thenReturn(true);

    }