@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());
    }
    @Before
    public void setUp() throws Exception {
      loadBalancer = new LoadBalancer();
      loadBalancer.setAccountId(1000);
      loadBalancer.setName("integration testing");
      loadBalancer.setPort(80);
      loadBalancer.setProtocol(LoadBalancerProtocol.POP3);

      Set<Node> nodes = new HashSet<Node>();
      Node node = new Node();
      node.setIpAddress("2.2.2.2");
      node.setPort(80);
      node.setCondition(NodeCondition.ENABLED);
      nodes.add(node);
      loadBalancer.setNodes(nodes);

      UserPages userPages = new UserPages();
      userPages.setErrorpage("aError");
      userPages.setLoadbalancer(loadBalancer);
      loadBalancer.setUserPages(userPages);

      loadBalancer = createLoadBalancerInActiveStatus(loadBalancer);

      accessList = new AccessList();
      accessList.setIpAddress("new ip");
      accessList.setType(AccessListType.ALLOW);
    }
  protected static void setupIvars() {
    Set<LoadBalancerJoinVip> vipList = new HashSet<LoadBalancerJoinVip>();
    vip1 = new VirtualIp();
    vip1.setId(TEST_VIP_ID);
    vip1.setIpAddress("10.69.0.59");
    vip2 = new VirtualIp();
    vip2.setId(TEST_VIP_ID + 1);
    vip2.setIpAddress("10.69.0.60");
    LoadBalancerJoinVip loadBalancerJoinVip = new LoadBalancerJoinVip();
    loadBalancerJoinVip.setVirtualIp(vip1);
    vipList.add(loadBalancerJoinVip);
    loadBalancerJoinVip = new LoadBalancerJoinVip();
    loadBalancerJoinVip.setVirtualIp(vip2);
    vipList.add(loadBalancerJoinVip);

    Set<Node> nodeList = new HashSet<Node>();
    node1 = new Node();
    node2 = new Node();
    node1.setIpAddress("127.0.0.1");
    node2.setIpAddress("127.0.0.2");
    node1.setPort(80);
    node2.setPort(80);
    node1.setCondition(ENABLED);
    node2.setCondition(DISABLED);
    node1.setWeight(1);
    node2.setWeight(1);
    nodeList.add(node1);
    nodeList.add(node2);

    LoadBalancer lb = new LoadBalancer();
    lb.setId(TEST_LOADBALANCER_ID);
    lb.setAccountId(TEST_ACCOUNT_ID);
    lb.setPort(80);
    lb.setAlgorithm(ROUND_ROBIN);
    lb.setName("STM-TESTER");
    lb.setProtocol(HTTP);
    lb.setNodes(nodeList);
    lb.setLoadBalancerJoinVipSet(vipList);

    lb.setUserPages(new UserPages());

    STMTestBase.lb = lb;
  }
 public static LoadBalancer generateLoadBalancer() {
   LoadBalancer loadBalancer = new LoadBalancer();
   loadBalancer.setPort(port);
   Set<AccessList> accessLists = new HashSet<AccessList>();
   AccessList item = new AccessList();
   item.setUserName(username);
   item.setId(id);
   item.setIpAddress(ipv42);
   item.setType(AccessListType.DENY);
   item.setLoadbalancer(loadBalancer);
   accessLists.add(item);
   loadBalancer.setAccessLists(accessLists);
   loadBalancer.setAccountId(accountId);
   loadBalancer.setAlgorithm(LoadBalancerAlgorithm.ROUND_ROBIN);
   ConnectionLimit limit = new ConnectionLimit();
   limit.setId(id);
   limit.setUserName(username);
   limit.setLoadBalancer(loadBalancer);
   limit.setMaxConnectionRate(maxConnectRate);
   limit.setMaxConnections(maxConnections);
   limit.setMinConnections(minConnections);
   limit.setRateInterval(rateInterval);
   loadBalancer.setConnectionLimit(limit);
   loadBalancer.setConnectionLogging(active);
   loadBalancer.setContentCaching(active);
   loadBalancer.setCreated(Calendar.getInstance());
   loadBalancer.setUpdated(Calendar.getInstance());
   loadBalancer.setHalfClosed(active);
   HealthMonitor monitor = new HealthMonitor();
   monitor.setUserName(username);
   monitor.setId(id);
   monitor.setAttemptsBeforeDeactivation(numAttempts);
   monitor.setBodyRegex(regex);
   monitor.setDelay(delay);
   monitor.setHostHeader(header);
   monitor.setLoadbalancer(loadBalancer);
   monitor.setStatusRegex(regex);
   monitor.setPath(path);
   monitor.setTimeout(timeout);
   monitor.setType(HealthMonitorType.CONNECT);
   loadBalancer.setHealthMonitor(monitor);
   loadBalancer.setHost(new Host());
   loadBalancer.setName(name);
   Set<Node> nodes = new HashSet<Node>();
   Node node = new Node();
   node.setId(id);
   node.setPort(port);
   node.setLoadbalancer(loadBalancer);
   node.setCondition(NodeCondition.ENABLED);
   node.setIpAddress(ipv43);
   List<NodeMeta> nodeMetadata = new ArrayList<NodeMeta>();
   NodeMeta nodeMeta = new NodeMeta();
   nodeMeta.setKey(metaKey);
   nodeMeta.setNode(node);
   nodeMeta.setValue(metaValue);
   nodeMeta.setId(id);
   nodeMeta.setUserName(username);
   nodeMetadata.add(nodeMeta);
   node.setNodeMetadata(nodeMetadata);
   node.setStatus(NodeStatus.ONLINE);
   node.setType(NodeType.PRIMARY);
   node.setWeight(weight);
   nodes.add(node);
   node = new Node();
   node.setId(id + 1);
   node.setPort(port);
   node.setLoadbalancer(loadBalancer);
   node.setCondition(NodeCondition.ENABLED);
   node.setIpAddress(ipv44);
   nodeMetadata = new ArrayList<NodeMeta>();
   nodeMeta = new NodeMeta();
   nodeMeta.setKey(metaKey);
   nodeMeta.setNode(node);
   nodeMeta.setValue(metaValue);
   nodeMeta.setId(id + 1);
   nodeMeta.setUserName(username);
   nodeMetadata.add(nodeMeta);
   node.setNodeMetadata(nodeMetadata);
   node.setStatus(NodeStatus.ONLINE);
   node.setType(NodeType.PRIMARY);
   node.setWeight(weight);
   nodes.add(node);
   loadBalancer.setNodes(nodes);
   Set<LoadbalancerMeta> lbMetadata = new HashSet<LoadbalancerMeta>();
   LoadbalancerMeta lbMeta = new LoadbalancerMeta();
   lbMeta.setUserName(username);
   lbMeta.setId(id);
   lbMeta.setKey(metaKey);
   lbMeta.setValue(metaValue);
   lbMeta.setLoadbalancer(loadBalancer);
   lbMetadata.add(lbMeta);
   loadBalancer.setLoadbalancerMetadata(lbMetadata);
   loadBalancer.setProtocol(LoadBalancerProtocol.HTTP);
   RateLimit limits = new RateLimit();
   limits.setLoadbalancer(loadBalancer);
   limits.setId(id);
   limits.setUserName(username);
   limits.setExpirationTime(Calendar.getInstance());
   limits.setMaxRequestsPerSecond(maxRequests);
   Ticket ticket = new Ticket();
   ticket.setUserName(username);
   ticket.setId(id);
   ticket.setLoadbalancer(loadBalancer);
   ticket.setComment(comment);
   ticket.setTicketId(ticketId);
   limits.setTicket(ticket);
   loadBalancer.setRateLimit(limits);
   loadBalancer.setSessionPersistence(SessionPersistence.HTTP_COOKIE);
   SslTermination termination = new SslTermination();
   termination.setId(id);
   termination.setEnabled(active);
   termination.setUserName(username);
   termination.setSecurePort(securePort);
   termination.setCertificate(cert);
   termination.setPrivatekey(key);
   termination.setSecureTrafficOnly(inactive);
   termination.setLoadbalancer(loadBalancer);
   loadBalancer.setSslTermination(termination);
   loadBalancer.setStatus(LoadBalancerStatus.ACTIVE);
   loadBalancer.setSticky(inactive);
   Suspension suspension = new Suspension();
   suspension.setUserName(username);
   suspension.setId(id);
   suspension.setLoadbalancer(loadBalancer);
   suspension.setUser(user);
   suspension.setReason(reason);
   suspension.setTicket(ticket);
   loadBalancer.setSuspension(suspension);
   Set<Ticket> tickets = new HashSet<Ticket>();
   tickets.add(ticket);
   loadBalancer.setTickets(tickets);
   loadBalancer.setTimeout(timeout);
   UserPages pages = new UserPages();
   pages.setLoadbalancer(loadBalancer);
   pages.setId(id);
   pages.setUserName(username);
   pages.setErrorpage(errorPage);
   loadBalancer.setUserPages(pages);
   loadBalancer.setId(id);
   loadBalancer.setUserName(username);
   Set<LoadBalancerJoinVip> vipList = spy(new HashSet<LoadBalancerJoinVip>());
   VirtualIp vip = new VirtualIp();
   vip.setId(1234);
   vip.setIpAddress("10.69.0.60");
   LoadBalancerJoinVip loadBalancerJoinVip = new LoadBalancerJoinVip();
   loadBalancerJoinVip.setVirtualIp(vip);
   vipList.add(loadBalancerJoinVip);
   loadBalancer.setLoadBalancerJoinVipSet(vipList);
   return loadBalancer;
 }