@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 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());
    }
    @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);

    }