embulk-filter-row 0.2.0 → 0.2.1

data/src/test/java/org/embulk/filter/row/TestConditionFactory.java

@@ -1,43 +1,66 @@
 package org.embulk.filter.row;
 
-import org.embulk.spi.Column;
-import org.embulk.spi.type.Type;
-import static org.embulk.spi.type.Types.*;
-import org.embulk.spi.type.BooleanType;
-import org.embulk.spi.type.LongType;
-import org.embulk.spi.type.DoubleType;
-import org.embulk.spi.type.StringType;
-import org.embulk.spi.type.TimestampType;
-import org.embulk.spi.time.Timestamp;
+import com.google.common.base.Optional;
+
 import org.embulk.config.ConfigException;
 import org.embulk.config.TaskSource;
+import org.embulk.spi.Column;
 
-import org.embulk.filter.row.ConditionConfig;
-import org.embulk.filter.row.ConditionFactory;
-import org.embulk.filter.row.BooleanCondition;
-import org.embulk.filter.row.DoubleCondition;
-import org.embulk.filter.row.Condition;
-import org.embulk.filter.row.StringCondition;
-import org.embulk.filter.row.TimestampCondition;
-
-import com.google.common.base.Optional;
 import org.jruby.embed.ScriptingContainer;
 import org.junit.Test;
-import static org.junit.Assert.*;
-import java.lang.NullPointerException;
+
+import static org.embulk.spi.type.Types.BOOLEAN;
+import static org.embulk.spi.type.Types.DOUBLE;
+import static org.embulk.spi.type.Types.LONG;
+import static org.embulk.spi.type.Types.STRING;
+import static org.embulk.spi.type.Types.TIMESTAMP;
+
+//import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 public class TestConditionFactory
 {
     public class DefaultConditionConfig implements ConditionConfig
     {
-        public String getColumn()             { return "column"; }
-        public Optional<String> getOperator() { return Optional.of("IS NULL"); }
-        public Optional<Object> getArgument() { return Optional.absent(); }
-        public Optional<Boolean> getNot()     { return Optional.of(false); }
-        public Optional<String> getFormat()   { return Optional.of("%Y-%m-%d"); }
-        public Optional<String> getTimezone() { return Optional.of("UTC"); }
-        public TaskSource dump()              { return null; }
-        public void validate()                {}
+        public String getColumn()
+        {
+            return "column";
+        }
+
+        public Optional<String> getOperator()
+        {
+            return Optional.of("IS NULL");
+        }
+
+        public Optional<Object> getArgument()
+        {
+            return Optional.absent();
+        }
+
+        public Optional<Boolean> getNot()
+        {
+            return Optional.of(false);
+        }
+
+        public Optional<String> getFormat()
+        {
+            return Optional.of("%Y-%m-%d");
+        }
+
+        public Optional<String> getTimezone()
+        {
+            return Optional.of("UTC");
+        }
+
+        public TaskSource dump()
+        {
+            return null;
+        }
+
+        public void validate()
+        {
+        }
     }
 
     private final ScriptingContainer jruby;
@@ -48,185 +71,292 @@ public class TestConditionFactory
     }
 
     @Test
-    public void testCreateBooleanCondition() {
+    public void testCreateBooleanCondition()
+    {
         Column column = new Column(0, "column", BOOLEAN);
         ConditionConfig  config;
         BooleanCondition condition;
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("IS NULL"); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("IS NULL");
+            }
         };
-        condition = (BooleanCondition)new ConditionFactory(jruby, column, config).createCondition();
+        condition = (BooleanCondition) new ConditionFactory(jruby, column, config).createCondition();
         assertTrue(condition.compare(null));
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.absent(); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("==");
+            }
+            public Optional<Object> getArgument()
+            {
+                return Optional.absent();
+            }
         };
         try {
-            condition = (BooleanCondition)new ConditionFactory(jruby, column, config).createCondition();
+            condition = (BooleanCondition) new ConditionFactory(jruby, column, config).createCondition();
             fail("Argument is required");
-        } catch (ConfigException e) {
+        }
+        catch (ConfigException e) {
         }
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of((Object)new Boolean(true)); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("==");
+            }
+            public Optional<Object> getArgument()
+            {
+                return Optional.of((Object) new Boolean(true));
+            }
         };
-        condition = (BooleanCondition)new ConditionFactory(jruby, column, config).createCondition();
+        condition = (BooleanCondition) new ConditionFactory(jruby, column, config).createCondition();
         assertTrue(condition.compare(new Boolean(true)));
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of((Object)new Long(10)); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("==");
+            }
+            public Optional<Object> getArgument()
+            {
+                return Optional.of((Object) new Long(10));
+            }
         };
         try {
-            condition = (BooleanCondition)new ConditionFactory(jruby, column, config).createCondition();
+            condition = (BooleanCondition) new ConditionFactory(jruby, column, config).createCondition();
             fail("Argument type mismatch");
-        } catch (ConfigException e) {
+        }
+        catch (ConfigException e) {
         }
     }
 
     @Test
-    public void testCreateDoubleCondition() {
+    public void testCreateDoubleCondition()
+    {
         Column column = new Column(0, "column", DOUBLE);
         ConditionConfig  config;
         DoubleCondition condition;
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("IS NULL"); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("IS NULL");
+            }
         };
-        condition = (DoubleCondition)new ConditionFactory(jruby, column, config).createCondition();
+        condition = (DoubleCondition) new ConditionFactory(jruby, column, config).createCondition();
         assertTrue(condition.compare(null));
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.absent(); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("==");
+            }
+            public Optional<Object> getArgument()
+            {
+                return Optional.absent();
+            }
         };
         try {
-            condition = (DoubleCondition)new ConditionFactory(jruby, column, config).createCondition();
+            condition = (DoubleCondition) new ConditionFactory(jruby, column, config).createCondition();
             fail("Argument is required");
-        } catch (ConfigException e) {
+        }
+        catch (ConfigException e) {
         }
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of((Object)new Double(10)); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("==");
+            }
+            public Optional<Object> getArgument()
+            {
+                return Optional.of((Object) new Double(10));
+            }
         };
-        condition = (DoubleCondition)new ConditionFactory(jruby, column, config).createCondition();
+        condition = (DoubleCondition) new ConditionFactory(jruby, column, config).createCondition();
         assertTrue(condition.compare(new Double(10)));
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of((Object)new Boolean(true)); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("==");
+            }
+            public Optional<Object> getArgument()
+            {
+                return Optional.of((Object) new Boolean(true));
+            }
         };
         try {
-            condition = (DoubleCondition)new ConditionFactory(jruby, column, config).createCondition();
+            condition = (DoubleCondition) new ConditionFactory(jruby, column, config).createCondition();
             fail("Argument type mismatch");
-        } catch (ConfigException e) {
+        }
+        catch (ConfigException e) {
         }
     }
 
     @Test
-    public void testCreateLongCondition() {
+    public void testCreateLongCondition()
+    {
         Column column = new Column(0, "column", LONG);
         ConditionConfig  config;
         LongCondition condition;
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("IS NULL"); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("IS NULL");
+            }
         };
-        condition = (LongCondition)new ConditionFactory(jruby, column, config).createCondition();
+        condition = (LongCondition) new ConditionFactory(jruby, column, config).createCondition();
         assertTrue(condition.compare(null));
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.absent(); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("==");
+            }
+            public Optional<Object> getArgument()
+            {
+                return Optional.absent();
+            }
         };
         try {
-            condition = (LongCondition)new ConditionFactory(jruby, column, config).createCondition();
+            condition = (LongCondition) new ConditionFactory(jruby, column, config).createCondition();
             fail("Argument is required");
-        } catch (ConfigException e) {
+        }
+        catch (ConfigException e) {
         }
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of((Object)new Long(10)); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("==");
+            }
+            public Optional<Object> getArgument()
+            {
+                return Optional.of((Object) new Long(10));
+            }
         };
-        condition = (LongCondition)new ConditionFactory(jruby, column, config).createCondition();
+        condition = (LongCondition) new ConditionFactory(jruby, column, config).createCondition();
         assertTrue(condition.compare(new Long(10)));
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of((Object)new Boolean(true)); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("==");
+            }
+            public Optional<Object> getArgument()
+            {
+                return Optional.of((Object) new Boolean(true));
+            }
         };
         try {
-            condition = (LongCondition)new ConditionFactory(jruby, column, config).createCondition();
+            condition = (LongCondition) new ConditionFactory(jruby, column, config).createCondition();
             fail("Argument type mismatch");
-        } catch (ConfigException e) {
+        }
+        catch (ConfigException e) {
         }
     }
 
     @Test
-    public void testCreateStringCondition() {
+    public void testCreateStringCondition()
+    {
         Column column = new Column(0, "column", STRING);
         ConditionConfig  config;
         StringCondition condition;
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("IS NULL"); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("IS NULL");
+            }
         };
-        condition = (StringCondition)new ConditionFactory(jruby, column, config).createCondition();
+        condition = (StringCondition) new ConditionFactory(jruby, column, config).createCondition();
         assertTrue(condition.compare(null));
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.absent(); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("==");
+            }
+            public Optional<Object> getArgument()
+            {
+                return Optional.absent();
+            }
         };
         try {
-            condition = (StringCondition)new ConditionFactory(jruby, column, config).createCondition();
+            condition = (StringCondition) new ConditionFactory(jruby, column, config).createCondition();
             fail("Argument is required");
-        } catch (ConfigException e) {
+        }
+        catch (ConfigException e) {
         }
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of((Object)"foo"); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("==");
+            }
+            public Optional<Object> getArgument()
+            {
+                return Optional.of((Object) "foo");
+            }
         };
-        condition = (StringCondition)new ConditionFactory(jruby, column, config).createCondition();
+        condition = (StringCondition) new ConditionFactory(jruby, column, config).createCondition();
         assertTrue(condition.compare("foo"));
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of((Object)new Boolean(true)); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("==");
+            }
+            public Optional<Object> getArgument()
+            {
+                return Optional.of((Object) new Boolean(true));
+            }
         };
         try {
-            condition = (StringCondition)new ConditionFactory(jruby, column, config).createCondition();
+            condition = (StringCondition) new ConditionFactory(jruby, column, config).createCondition();
             fail("Argument type mismatch");
-        } catch (ConfigException e) {
+        }
+        catch (ConfigException e) {
         }
     }
 
     @Test
-    public void testCreateTimestampCondition() {
+    public void testCreateTimestampCondition()
+    {
         Column column = new Column(0, "column", TIMESTAMP);
         ConditionConfig  config;
         TimestampCondition condition;
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("IS NULL"); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("IS NULL");
+            }
         };
-        condition = (TimestampCondition)new ConditionFactory(jruby, column, config).createCondition();
+        condition = (TimestampCondition) new ConditionFactory(jruby, column, config).createCondition();
         assertTrue(condition.compare(null));
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.absent(); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("==");
+            }
+            public Optional<Object> getArgument()
+            {
+                return Optional.absent();
+            }
         };
         try {
-            condition = (TimestampCondition)new ConditionFactory(jruby, column, config).createCondition();
+            condition = (TimestampCondition) new ConditionFactory(jruby, column, config).createCondition();
             fail("Argument is required");
-        } catch (ConfigException e) {
+        }
+        catch (ConfigException e) {
         }
 
         //ToDo: How to create jruby object correctly?
@@ -238,13 +368,20 @@ public class TestConditionFactory
         //condition = (TimestampCondition)new ConditionFactory(jruby, column, config).createCondition();
 
         config = new DefaultConditionConfig() {
-            public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of((Object)new Boolean(true)); }
+            public Optional<String> getOperator()
+            {
+                return Optional.of("==");
+            }
+            public Optional<Object> getArgument()
+            {
+                return Optional.of((Object) new Boolean(true));
+            }
         };
         try {
-            condition = (TimestampCondition)new ConditionFactory(jruby, column, config).createCondition();
+            condition = (TimestampCondition) new ConditionFactory(jruby, column, config).createCondition();
             fail("Argument type mismatch");
-        } catch (ConfigException e) {
+        }
+        catch (ConfigException e) {
         }
     }
 }

data/src/test/java/org/embulk/filter/row/TestDoubleCondition.java

@@ -1,81 +1,105 @@
 package org.embulk.filter.row;
 
-import org.embulk.filter.row.DoubleCondition;
 import org.junit.Test;
-import static org.junit.Assert.*;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 public class TestDoubleCondition
 {
     @Test
-    public void testIsNull() {
+    public void testIsNull()
+    {
         DoubleCondition condition = new DoubleCondition("IS NULL", null, false);
         assertTrue(condition.compare(null));
         assertFalse(condition.compare(new Double(10)));
     }
 
     @Test
-    public void testIsNotNull() {
+    public void testIsNotNull()
+    {
         DoubleCondition condition = new DoubleCondition("IS NOT NULL", null, false);
         assertFalse(condition.compare(null));
         assertTrue(condition.compare(new Double(10)));
     }
 
     @Test
-    public void testEquals() {
+    public void testEquals()
+    {
         DoubleCondition condition = new DoubleCondition("==", new Double(10), false);
         assertFalse(condition.compare(null));
-        assertTrue( condition.compare(new Double(10)));
+        assertTrue(condition.compare(new Double(10)));
         assertFalse(condition.compare(new Double(11)));
+        assertTrue(condition.compare(new Double(10.0)));
+        assertFalse(condition.compare(new Double(11.0)));
 
         // Prohibited by Factory
         // DoubleCondition condition = new DoubleCondition("==", null, false);
     }
 
     @Test
-    public void testNotEquals() {
+    public void testNotEquals()
+    {
         DoubleCondition condition = new DoubleCondition("!=", new Double(10), false);
-        assertTrue( condition.compare(null));
+        assertTrue(condition.compare(null));
         assertFalse(condition.compare(new Double(10)));
-        assertTrue( condition.compare(new Double(11)));
+        assertTrue(condition.compare(new Double(11)));
+        assertFalse(condition.compare(new Double(10.0)));
+        assertTrue(condition.compare(new Double(11.0)));
     }
 
     @Test
-    public void testGreaterThan() {
+    public void testGreaterThan()
+    {
         DoubleCondition condition = new DoubleCondition(">", new Double(10), false);
         assertFalse(condition.compare(null));
         assertFalse(condition.compare(new Double(10)));
-        assertTrue( condition.compare(new Double(11)));
+        assertTrue(condition.compare(new Double(11)));
+        assertFalse(condition.compare(new Double(10.0)));
+        assertTrue(condition.compare(new Double(11.0)));
     }
 
     @Test
-    public void testGreaterEqual() {
+    public void testGreaterEqual()
+    {
         DoubleCondition condition = new DoubleCondition(">=", new Double(11), false);
         assertFalse(condition.compare(null));
         assertFalse(condition.compare(new Double(10)));
-        assertTrue( condition.compare(new Double(11)));
+        assertTrue(condition.compare(new Double(11)));
+        assertFalse(condition.compare(new Double(10.0)));
+        assertTrue(condition.compare(new Double(11.0)));
     }
 
     @Test
-    public void testLessThan() {
+    public void testLessThan()
+    {
         DoubleCondition condition = new DoubleCondition("<", new Double(11), false);
         assertFalse(condition.compare(null));
         assertFalse(condition.compare(new Double(11)));
-        assertTrue( condition.compare(new Double(10)));
+        assertTrue(condition.compare(new Double(10)));
+        assertFalse(condition.compare(new Double(11.0)));
+        assertTrue(condition.compare(new Double(10.0)));
     }
 
     @Test
-    public void testLessEqual() {
+    public void testLessEqual()
+    {
         DoubleCondition condition = new DoubleCondition("<=", new Double(11), false);
         assertFalse(condition.compare(null));
         assertFalse(condition.compare(new Double(12)));
-        assertTrue( condition.compare(new Double(11)));
+        assertTrue(condition.compare(new Double(11)));
+        assertFalse(condition.compare(new Double(12.0)));
+        assertTrue(condition.compare(new Double(11.0)));
     }
 
     @Test
-    public void testNot() {
+    public void testNot()
+    {
         DoubleCondition condition = new DoubleCondition("<=", new Double(11), true);
-        assertTrue( condition.compare(null));
-        assertTrue( condition.compare(new Double(12)));
+        assertTrue(condition.compare(null));
+        assertTrue(condition.compare(new Double(12)));
         assertFalse(condition.compare(new Double(11)));
+        assertTrue(condition.compare(new Double(12.0)));
+        assertFalse(condition.compare(new Double(11.0)));
     }
 }