PModelTest.java

package be.selckin.swu.pmodel;

import be.selckin.swu.pmodel.PModel.PModeler;
import be.selckin.swu.pmodel.test.Bar;
import be.selckin.swu.pmodel.test.Foo;
import be.selckin.swu.pmodel.test.SomeClass;
import be.selckin.swu.pmodel.test.SomeClass.Inner;
import be.selckin.swu.pmodel.test.SomeClass.InnerStatic;
import org.apache.wicket.WicketRuntimeException;
import org.apache.wicket.model.IModel;
import org.apache.wicket.model.Model;
import org.apache.wicket.util.tester.WicketTester;
import org.testng.Assert;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

@Test
public class PModelTest {

    private WicketTester wicketTester;

    @BeforeClass
    public void setUp() {
        wicketTester = new WicketTester();
    }

    @AfterClass
    public void tearDown() {
        wicketTester.destroy();
    }

    public void test1() {
        SomeClass someClass = new SomeClass();
        IModel<SomeClass> root = Model.of(someClass);
        IModel<String> model = PModel.model(PModel.bean(SomeClass.class, root).getString());

        someClass.setString("foo");
        Assert.assertEquals(model.getObject(), "foo");
        model.setObject("bar");
        Assert.assertEquals(model.getObject(), "bar");
        Assert.assertEquals(someClass.getString(), "bar");
    }

    public void test2() {
        SomeClass someClass = new SomeClass();
        IModel<SomeClass> root = Model.of(someClass);
        IModel<Float> model = PModel.model(PModel.bean(SomeClass.class, root).getNumber());

        someClass.setNumber(5f);
        Assert.assertEquals(model.getObject(), 5f);
        model.setObject(10f);
        Assert.assertEquals(model.getObject(), 10f);
        Assert.assertEquals(someClass.getNumber(), 10f);
    }

    public void test3() {
        SomeClass someClass = new SomeClass();
        IModel<SomeClass> root = Model.of(someClass);
        IModel<Foo> model = PModel.model(PModel.bean(SomeClass.class, root).getFoo());

        Assert.assertEquals(model.getObject(), null);
        Foo foo = new Foo(8);
        model.setObject(foo);
        Assert.assertEquals(model.getObject(), foo);
        Assert.assertEquals(someClass.getFoo(), foo);
    }


    public void testInnerStatic() {
        SomeClass someClass = new SomeClass();
        IModel<SomeClass> root = Model.of(someClass);
        IModel<InnerStatic> model = PModel.model(PModel.bean(SomeClass.class, root).getInnerStatic());

        Assert.assertEquals(model.getObject(), null);
        InnerStatic innerStatic = new InnerStatic();
        model.setObject(innerStatic);
        Assert.assertEquals(model.getObject(), innerStatic);
        Assert.assertEquals(someClass.getInnerStatic(), innerStatic);
    }

    public void testInner() {
        SomeClass someClass = new SomeClass();
        IModel<SomeClass> root = Model.of(someClass);
        IModel<Inner> model = PModel.model(PModel.bean(SomeClass.class, root).getInner1());

        Assert.assertEquals(model.getObject(), null);
        Inner inner = someClass.new Inner();
        model.setObject(inner);
        Assert.assertEquals(model.getObject(), inner);
        Assert.assertEquals(someClass.getInner1(), inner);
    }

    @Test(expectedExceptions = WicketRuntimeException.class)
    public void test4() {
        SomeClass someClass = new SomeClass();
        IModel<SomeClass> root = Model.of(someClass);
        IModel<Bar> model = PModel.model(PModel.bean(SomeClass.class, root).getFoo().getBar());

        Assert.assertEquals(model.getObject(), null);
        model.setObject(new Bar());
    }

    public void test5() {
        SomeClass someClass = new SomeClass();
        Foo foo = new Foo(7);
        someClass.setFoo(foo);
        IModel<SomeClass> root = Model.of(someClass);
        IModel<Bar> model = PModel.model(PModel.bean(SomeClass.class, root).getFoo().getBar());

        Assert.assertEquals(model.getObject(), null);
        Bar bar = new Bar();
        model.setObject(bar);
        Assert.assertEquals(model.getObject(), bar);
        Assert.assertEquals(foo.getBar(), bar);
    }

    public void test6() {
        SomeClass someClass = new SomeClass();
        Foo foo = new Foo(7);
        someClass.setFoo(foo);
        Bar bar = new Bar();
        foo.setBar(bar);
        IModel<SomeClass> root = Model.of(someClass);
        IModel<Integer> model = PModel.model(PModel.bean(SomeClass.class, root).getFoo().getBar().getMoo());

        assertTest6(bar, model);
    }

    public void test6er() {
        SomeClass someClass = new SomeClass();
        Foo foo = new Foo(7);
        someClass.setFoo(foo);
        Bar bar = new Bar();
        foo.setBar(bar);
        IModel<SomeClass> root = Model.of(someClass);

        IModel<Integer> model = PModel.model(PModel.modeler(SomeClass.class, root).bean().getFoo().getBar().getMoo());

        assertTest6(bar, model);
    }

    private void assertTest6(Bar bar, IModel<Integer> model) {
        Assert.assertEquals(model.getObject(), null);
        model.setObject(5);
        Assert.assertEquals(model.getObject(), new Integer(5));
        Assert.assertEquals(bar.getMoo(), new Integer(5));
    }

    public void test7() {
        SomeClass someClass = new SomeClass();
        IModel<SomeClass> root = Model.of(someClass);
        IModel<Boolean> model = PModel.model(PModel.bean(SomeClass.class, root).isEmpty());

        asserttest7(someClass, model);
    }

    public void test7er() {
        SomeClass someClass = new SomeClass();
        IModel<SomeClass> root = Model.of(someClass);

        PModeler<SomeClass> modeler = PModel.modeler(SomeClass.class, root);

        IModel<Boolean> model = PModel.model(modeler.bean().isEmpty());

        asserttest7(someClass, model);
    }

    private void asserttest7(SomeClass someClass, IModel<Boolean> model) {
        someClass.setEmpty(true);
        Assert.assertTrue(model.getObject());
        model.setObject(false);
        Assert.assertFalse(model.getObject());
        Assert.assertFalse(someClass.isEmpty());
        model.setObject(true);
        Assert.assertTrue(model.getObject());
        Assert.assertTrue(someClass.isEmpty());
    }

    public void testModelr() {
        SomeClass someClass = new SomeClass();
        Foo foo = new Foo(7);
        someClass.setFoo(foo);
        Bar bar = new Bar();
        foo.setBar(bar);

        PModeler<SomeClass> modeler = PModel.modeler(SomeClass.class, Model.of(someClass));

        IModel<Boolean> model = PModel.model(modeler.bean().isEmpty());

        Assert.assertEquals(foo, PModel.model(modeler.bean().getFoo()).getObject());
        Assert.assertEquals(new Integer(7), PModel.model(modeler.bean().getFoo().getI()).getObject());
        Assert.assertEquals(bar, PModel.model(modeler.bean().getFoo().getBar()).getObject());
    }
}