@Test
  public void testLeftJoin() throws Exception {
    Dao<Bar, Integer> barDao = createDao(Bar.class, true);
    Dao<Baz, Integer> bazDao = createDao(Baz.class, true);

    Bar bar1 = new Bar();
    bar1.val = 2234;
    assertEquals(1, barDao.create(bar1));
    Bar bar2 = new Bar();
    bar2.val = 324322234;
    assertEquals(1, barDao.create(bar2));

    Baz baz1 = new Baz();
    baz1.bar = bar1;
    assertEquals(1, bazDao.create(baz1));
    Baz baz2 = new Baz();
    baz2.bar = bar2;
    assertEquals(1, bazDao.create(baz2));
    Baz baz3 = new Baz();
    // no bar
    assertEquals(1, bazDao.create(baz3));

    QueryBuilder<Bar, Integer> barQb = barDao.queryBuilder();
    List<Baz> results = bazDao.queryBuilder().query();
    assertEquals(3, results.size());
    results = bazDao.queryBuilder().join(barQb).query();
    assertEquals(2, results.size());

    results = bazDao.queryBuilder().leftJoin(barQb).query();
    assertEquals(3, results.size());

    results = bazDao.queryBuilder().join(barQb, JoinType.LEFT, JoinWhereOperation.AND).query();
    assertEquals(3, results.size());
  }
Beispiel #2
0
  @Test
  public void testGeneric() {
    // Check that normal bean injection is working correctly!
    assertNotNull(baz2.getCorge());
    assertEquals(baz2.getCorge().getName(), "fred");

    // Test that the generic configuration injection wiring is working for bar
    assertNotNull(bar1.getInjectedMessage());
    assertEquals(bar1.getInjectedMessage().value(), "hello1");
    assertNotNull(bar2.getInjectedMessage());
    assertEquals(bar2.getInjectedMessage().value(), "hello2");

    // Check that the generic configuration injection wiring is working for baz
    assertNotNull(baz1.getMessage());
    assertEquals(baz1.getMessage().value(), "hello1");
    assertNotNull(baz2.getMessage());
    assertEquals(baz2.getMessage().value(), "hello2");

    assertNotNull(baz5.getMessage());
    assertEquals(baz5.getMessage().value(), "hello5");

    // Check that this isn't affecting annotations on the generic bean without @Inject
    assertNull(baz1.getBar().getMessage());
    assertNull(baz2.getBar().getMessage());
  }
  @Test
  public void testJoinOrder() throws Exception {
    Dao<Bar, Integer> barDao = createDao(Bar.class, true);
    Dao<Baz, Integer> bazDao = createDao(Baz.class, true);

    Bar bar1 = new Bar();
    bar1.val = 2234;
    assertEquals(1, barDao.create(bar1));
    Bar bar2 = new Bar();
    bar2.val = 324322234;
    assertEquals(1, barDao.create(bar2));

    Baz baz1 = new Baz();
    baz1.bar = bar1;
    assertEquals(1, bazDao.create(baz1));
    Baz baz2 = new Baz();
    baz2.bar = bar2;
    assertEquals(1, bazDao.create(baz2));

    QueryBuilder<Bar, Integer> barQb = barDao.queryBuilder();
    barQb.orderBy(Bar.VAL_FIELD, true);
    List<Baz> results = bazDao.queryBuilder().join(barQb).query();
    assertEquals(2, results.size());
    assertEquals(bar1.id, results.get(0).bar.id);
    assertEquals(bar2.id, results.get(1).bar.id);

    // reset the query to change the order direction
    barQb.reset();
    barQb.orderBy(Bar.VAL_FIELD, false);
    results = bazDao.queryBuilder().join(barQb).query();
    assertEquals(2, results.size());
    assertEquals(bar2.id, results.get(0).bar.id);
    assertEquals(bar1.id, results.get(1).bar.id);
  }
  @Test
  public void testJoinGroup() throws Exception {
    Dao<Bar, Integer> barDao = createDao(Bar.class, true);
    Dao<Baz, Integer> bazDao = createDao(Baz.class, true);

    Bar bar1 = new Bar();
    bar1.val = 2234;
    assertEquals(1, barDao.create(bar1));
    Bar bar2 = new Bar();
    bar2.val = 324322234;
    assertEquals(1, barDao.create(bar2));

    Baz baz1 = new Baz();
    baz1.bar = bar1;
    assertEquals(1, bazDao.create(baz1));
    Baz baz2 = new Baz();
    baz2.bar = bar2;
    assertEquals(1, bazDao.create(baz2));

    QueryBuilder<Bar, Integer> barQb = barDao.queryBuilder();
    barQb.where().eq(Bar.VAL_FIELD, bar1.val);
    barQb.groupBy(Bar.ID_FIELD);
    List<Baz> results = bazDao.queryBuilder().query();
    assertEquals(2, results.size());
    results = bazDao.queryBuilder().groupBy(Baz.ID_FIELD).join(barQb).query();
    assertEquals(1, results.size());
    assertEquals(bar1.id, results.get(0).bar.id);
  }
  @Test
  public void testBaseClassComparison() throws Exception {
    Dao<Bar, String> barDao = createDao(Bar.class, true);
    Dao<Baz, String> bazDao = createDao(Baz.class, true);

    BarSuperClass bar1 = new BarSuperClass();
    bar1.val = 10;
    assertEquals(1, barDao.create(bar1));

    Baz baz1 = new Baz();
    baz1.bar = bar1;
    assertEquals(1, bazDao.create(baz1));

    List<Baz> results = bazDao.queryBuilder().where().eq(Baz.BAR_FIELD, bar1).query();
    assertEquals(1, results.size());
    assertEquals(bar1.id, results.get(0).bar.id);

    try {
      // we allow a super class of the field but _not_ a sub class
      results = bazDao.queryBuilder().where().eq(Baz.BAR_FIELD, new Object()).query();
      fail("Should have thrown");
    } catch (SQLException e) {
      // expected
    }
  }
 public void testCustomizeAssemblerFactory() throws Exception {
   configure("AssemblerFactory.dicon");
   S2Container container =
       S2ContainerFactory.create(getClass().getName().replace('.', '/') + ".foo.dicon");
   container.init();
   Baz baz = (Baz) container.getComponent("baz");
   assertNull("1", baz.getFoo());
 }
Beispiel #7
0
 @Test
 public void testScope() {
   assertNotSame(baz1.getCorge(), baz2.getCorge());
   assertNotNull(baz3);
   assertNotNull(baz3a);
   assertEquals(baz3.getCorge(), baz3a.getCorge());
   assertNotNull(baz4);
   assertNotNull(baz4a);
   assertEquals(baz4.getCorge(), baz4a.getCorge());
   assertNotSame(baz3.getCorge(), baz4.getCorge());
 }
  @Test
  public void testMultipleJoin() throws Exception {
    Dao<Bar, Integer> barDao = createDao(Bar.class, true);
    Dao<Baz, Integer> bazDao = createDao(Baz.class, true);
    Dao<Bing, Integer> bingDao = createDao(Bing.class, true);

    Bar bar1 = new Bar();
    bar1.val = 2234;
    assertEquals(1, barDao.create(bar1));
    Bar bar2 = new Bar();
    bar2.val = 324322234;
    assertEquals(1, barDao.create(bar2));

    Baz baz1 = new Baz();
    baz1.bar = bar1;
    assertEquals(1, bazDao.create(baz1));
    Baz baz2 = new Baz();
    baz2.bar = bar2;
    assertEquals(1, bazDao.create(baz2));

    Bing bing1 = new Bing();
    bing1.baz = baz1;
    assertEquals(1, bingDao.create(bing1));
    Bing bing2 = new Bing();
    bing2.baz = baz1;
    assertEquals(1, bingDao.create(bing2));

    QueryBuilder<Bar, Integer> barQb = barDao.queryBuilder();
    barQb.where().eq(Bar.VAL_FIELD, bar1.val);
    List<Baz> results = bazDao.queryBuilder().query();
    assertEquals(2, results.size());

    QueryBuilder<Bing, Integer> bingQb = bingDao.queryBuilder();
    bingQb.where().eq(Bing.ID_FIELD, bing2.id);
    List<Baz> bingResults = bazDao.queryBuilder().query();
    assertEquals(2, bingResults.size());

    results = bazDao.queryBuilder().join(barQb).join(bingQb).query();
    assertEquals(1, results.size());
    assertEquals(bar1.id, results.get(0).bar.id);
  }
Beispiel #9
0
  /**
   * Verify RobustReflectionConverter can handle missing fields in a class extending
   * Throwable/Exception (default ThrowableConverter registered by XStream calls ReflectionConverter
   * directly, rather than our RobustReflectionConverter replacement). (HUDSON-5769)
   */
  public void testUnmarshalThrowableMissingField() {
    Baz baz = new Baz();
    baz.myFailure = new Exception("foo");

    XStream2 xs = new XStream2();
    String xml = xs.toXML(baz);
    baz = (Baz) xs.fromXML(xml);
    assertEquals("foo", baz.myFailure.getMessage());

    baz =
        (Baz)
            xs.fromXML(
                "<hudson.util.XStream2Test_-Baz><myFailure>"
                    + "<missingField>true</missingField>"
                    + "<detailMessage>hoho</detailMessage>"
                    + "<stackTrace><trace>"
                    + "hudson.util.XStream2Test.testUnmarshalThrowableMissingField(XStream2Test.java:97)"
                    + "</trace></stackTrace>"
                    + "</myFailure></hudson.util.XStream2Test_-Baz>");
    // Object should load, despite "missingField" in XML above
    assertEquals("hoho", baz.myFailure.getMessage());
  }
  @Test
  public void testSimpleJoinColumnArg() throws Exception {
    Dao<Bar, Integer> barDao = createDao(Bar.class, true);
    Dao<Baz, Integer> bazDao = createDao(Baz.class, true);

    Bar bar1 = new Bar();
    int val = 1313123;
    bar1.val = val;
    assertEquals(1, barDao.create(bar1));
    Bar bar2 = new Bar();
    bar2.val = val;
    assertEquals(1, barDao.create(bar2));

    Baz baz1 = new Baz();
    baz1.bar = bar1;
    baz1.val = val;
    assertEquals(1, bazDao.create(baz1));
    Baz baz2 = new Baz();
    baz2.bar = bar2;
    baz2.val = val + 1;
    assertEquals(1, bazDao.create(baz2));
    Baz baz3 = new Baz();
    baz1.bar = bar2;
    baz1.val = val;
    assertEquals(1, bazDao.create(baz3));
    Baz baz4 = new Baz();
    baz2.bar = bar1;
    baz2.val = val;
    assertEquals(1, bazDao.create(baz4));

    QueryBuilder<Bar, Integer> barQb = barDao.queryBuilder();
    barQb.where().eq(Bar.VAL_FIELD, new ColumnArg("baz", Baz.VAL_FIELD));
    List<Baz> results = bazDao.queryBuilder().query();
    assertEquals(4, results.size());
    results = bazDao.queryBuilder().join(barQb).query();
    assertEquals(1, results.size());
    assertEquals(bar1.id, results.get(0).bar.id);
  }
  @Test
  public void testSimpleJoinOr() throws Exception {
    Dao<Bar, Integer> barDao = createDao(Bar.class, true);
    Dao<Baz, Integer> bazDao = createDao(Baz.class, true);

    Bar bar1 = new Bar();
    bar1.val = 2234;
    assertEquals(1, barDao.create(bar1));
    Bar bar2 = new Bar();
    bar2.val = 324322234;
    assertEquals(1, barDao.create(bar2));

    Baz baz1 = new Baz();
    baz1.bar = bar1;
    baz1.val = 423423;
    assertEquals(1, bazDao.create(baz1));
    Baz baz2 = new Baz();
    baz2.bar = bar2;
    baz2.val = 9570423;
    assertEquals(1, bazDao.create(baz2));

    QueryBuilder<Bar, Integer> barQb = barDao.queryBuilder();
    barQb.where().eq(Bar.VAL_FIELD, bar1.val);
    List<Baz> results = bazDao.queryBuilder().query();
    assertEquals(2, results.size());
    QueryBuilder<Baz, Integer> bazQb = bazDao.queryBuilder();
    bazQb.where().eq(Baz.VAL_FIELD, baz2.val);
    results = bazQb.joinOr(barQb).query();
    assertEquals(2, results.size());
    assertEquals(bar1.id, results.get(0).bar.id);
    assertEquals(bar2.id, results.get(1).bar.id);

    bazQb.reset();
    bazQb.where().eq(Baz.VAL_FIELD, baz2.val);
    results = bazQb.join(barQb, JoinType.INNER, JoinWhereOperation.OR).query();
    assertEquals(2, results.size());
    assertEquals(bar1.id, results.get(0).bar.id);
    assertEquals(bar2.id, results.get(1).bar.id);

    // now do join which should be an AND
    bazQb.reset();
    bazQb.where().eq(Baz.VAL_FIELD, baz2.val);
    results = bazQb.join(barQb).query();
    // should find no results
    assertEquals(0, results.size());
  }
 public void testBaz() throws Exception {
   Baz baz = SerializableObjects.baz;
   roundTrip(baz, Baz.getSchema(), Baz.getPipeSchema());
 }
Beispiel #13
0
  @Test(description = "A simple test to check conversation replication")
  public void testConversationReplication() throws Exception {

    TestContainer container1 = bootstrapContainer(1, Collections.singletonList(Baz.class));
    BeanManagerImpl beanManager1 = getBeanManager(container1);

    TestContainer container2 = bootstrapContainer(2, Collections.singletonList(Baz.class));
    BeanManagerImpl beanManager2 = getBeanManager(container2);

    use(1);

    // Set up the conversation context
    BoundRequest request1 = new BoundRequestImpl(container1.getSessionStore());
    BoundConversationContext conversationContext1 =
        Utils.getReference(beanManager1, BoundConversationContext.class);
    conversationContext1.associate(request1);
    conversationContext1.activate();

    // Set a value into Baz1
    Baz baz1 = Utils.getReference(beanManager1, Baz.class);
    baz1.setName("pete");

    // Begin the conversation
    Conversation conversation1 = Utils.getReference(beanManager1, Conversation.class);
    conversation1.begin();

    // refetch the test bean and check it has the right value
    baz1 = Utils.getReference(beanManager1, Baz.class);
    assert baz1.getName().equals("pete");

    // Simulate ending the request (from the POV of the conversation only!)
    assert !conversation1.isTransient();
    String cid = conversation1.getId();
    conversationContext1.invalidate();
    conversationContext1.deactivate();
    conversationContext1.dissociate(request1);

    // and start another, propagating the conversation
    request1 = new BoundRequestImpl(container1.getSessionStore());
    conversationContext1.associate(request1);
    conversationContext1.activate(cid);

    // refetch the test bean and check it has the right value
    baz1 = Utils.getReference(beanManager1, Baz.class);
    assert baz1.getName().equals("pete");
    assert !conversation1.isTransient();

    replicateSession(1, container1, 2, container2);

    use(2);

    // Set up the conversation context
    BoundRequest request2 = new BoundRequestImpl(container2.getSessionStore());
    BoundConversationContext conversationContext2 =
        Utils.getReference(beanManager2, BoundConversationContext.class);
    conversationContext2.associate(request2);
    conversationContext2.activate(cid);

    Baz baz2 = Utils.getReference(beanManager2, Baz.class);
    assert baz2.getName().equals("pete");

    Conversation conversation2 = Utils.getReference(beanManager2, Conversation.class);
    assert !conversation2.isTransient();

    use(2);
    container2.stopContainer();
    use(1);
    container1.stopContainer();
  }