First commit to github

Author: jvvlee

README.txt

@@ -0,0 +1,42 @@
+Jonathan Lee - ThoughtWorks Submission: Problem Two Sales Taxes
+==========
+
+Application Information:
+- Source code built in codio Online IDE
+- Written in Java:
+  java version "1.7.0_67"                                                                                            
+- Tested with junit ver. 4.12
+
+Instructions:
++++++
+To run the application on Unix-like systems:
+1) From the command line, cd into the src directory of this application
+2) Compile the .java file by entering "javac SalesTaxApp.java"
+3) Run the compiled class file with "java SalesTaxApp ../test/testinput1.txt" (Or use any other text file provided, or your own)
+
+To run tests:
+1) Download "junit-4.12.jar" and "hamcrest-core-1.3.jar", save these to the "src" directory
+2) Compile each test with the command "javac -cp junit-4.12.jar:hamcrest-core-1.3.jar:. <TESTJAVANAME>.java"
+3) The tests can be run individually with "java -cp junit-4.12.jar:hamcrest-core-1.3.jar:. org.junit.runner.JUnitCore <TESTCLASSNAME>"
+
+For the entire testing suite:
+2) Compile with "javac -cp junit-4.12.jar:hamcrest-core-1.3.jar:. SalesTaxAppTestSuite.java" 
+3) Run with "java -cp junit-4.12.jar:hamcrest-core-1.3.jar:. org.junit.runner.JUnitCore SalesTaxAppTestSuite"
+NOTE - This will run all the tests. But the individual tests will still need to be compiled to class files before the suite compilation will work.
+
+Design Details:
++++++
+- There are four main classes, the actual application (SalesTaxApp), Receipt, Good, and a FileReader
+- The file reader presents line-by-line information from text files in the form of String arrays
+- The Good is an object representation of items on the text list. There are getter methods for each field
+- The Receipt applies tax and can calculate the total price of items on its list
+- The application class ties together the above-mentioned classes and prints output to the console
+- Medicine and Food are classified by matching certain limited keyword to the name of the good.
+
+Design Assumptions:
++++++
+- File paths will be provided through command line args
+- The formatting of the items in the text file will always be "<Quantity> <Name> at <Price>/n"
+- The desired output should be printed to the console.
+
+Date Submitted: 3/2/15

src/Good.class

@@ -0,0 +1,24 @@
+public class Good {
+  private double price;
+  private int quantity;
+  private String name;
+  
+  //Attributes can only be set in initialize
+  public Good(int q, String n, double p) {
+    quantity = q;
+    name = n;
+    price = p;
+  }
+  
+  public double getPrice() {
+    return this.price;
+  }
+  
+  public int getQuantity() {
+    return this.quantity;
+  }
+  
+  public String getName() {
+    return this.name;
+  }
+}

src/Good.java

@@ -0,0 +1,29 @@
+import static org.junit.Assert.*;
+import org.junit.*;
+
+public class GoodTest {
+  private Good testGood;
+  
+  @Before
+  public void createTestGood() {
+    testGood = new Good(3, "bottles of oxiclean", 19.95);
+  }
+  
+  @Test
+  public void testGoodPrice() {
+    double price = 19.95;
+    assertEquals("Price of good is 19.95", price, testGood.getPrice(), 0.001);
+  }
+  
+  @Test
+  public void testGoodQuantity() {
+    int quantity = 3;
+    assertEquals("Quantity of good is 3", quantity, testGood.getQuantity());
+  }
+  
+  @Test
+  public void testGoodName() {
+    String name = "bottles of oxiclean";
+    assertEquals("Name of good is 'bottles of oxiclean'",name,testGood.getName());
+  }
+}

src/GoodTest.class

@@ -0,0 +1,34 @@
+import java.io.*;
+
+public class HelloWorld{
+
+     public static void main(String []args){
+        ByteArrayOutputStream os = new ByteArrayOutputStream();
+        PrintStream ps = new PrintStream(os);
+        PrintStream originalOut = System.out;
+       
+        System.setOut(ps);
+        
+        System.out.println("Nonono");
+ 
+        System.out.flush();
+        System.setOut(originalOut);
+        
+        System.out.println(ps.toString());
+//     ByteArrayOutputStream baos = new ByteArrayOutputStream();
+//     PrintStream ps = new PrintStream(baos);
+//     // IMPORTANT: Save the old System.out!
+//     PrintStream old = System.out;
+//     // Tell Java to use your special stream
+//     System.setOut(ps);
+//     // Print some output: goes to your special stream
+//     System.out.println("Foofoofoo!");
+//     // Put things back
+//     System.out.flush();
+//     System.setOut(old);
+//     // Show what happened
+//     System.out.println("Here: " + baos.toString());
+     }
+}
+
+//http://stackoverflow.com/questions/8708342/redirect-console-output-to-string-in-java

src/GoodTest.java

@@ -0,0 +1,46 @@
+import java.io.FileReader;
+import java.io.BufferedReader;
+import java.io.IOException;
+
+
+public class ReadFile {
+  private String filepath;
+  
+  //initializes with file path given, passes from command line args
+  public ReadFile (String fp) {
+    filepath = fp;
+  }
+  
+  public String[] openFile() throws IOException { //throws IOException to be handled in main application
+    
+    FileReader fileread = new FileReader(filepath);
+    BufferedReader textReader = new BufferedReader(fileread);
+    
+    int numLines = numberOfLines(filepath);
+    String[] textLineArray = new String[numLines];
+    
+    for (int i = 0; i < numLines; i++) {
+      textLineArray[i] = textReader.readLine();
+    }
+    
+    textReader.close();
+    return textLineArray;
+  }
+  
+  //finds number of lines to instantiate Array
+  private int numberOfLines(String path) throws IOException {
+    FileReader targetFile = new FileReader(path);
+    BufferedReader textStream = new BufferedReader(targetFile);
+    
+    String line;
+    int lineNumber = 0;
+    
+    while ((line = textStream.readLine()) != null) {
+      lineNumber++;
+    }
+    textStream.close();
+    
+    return lineNumber;
+  }
+  
+}

src/HelloWorld.java

@@ -0,0 +1,25 @@
+import static org.junit.Assert.*;
+import org.junit.*;
+import java.io.IOException;
+
+public class ReadFileTest {
+  private ReadFile testReadFile;
+  private String[] testStringArray;
+  
+  @Before
+  public void createFileReader() {
+    testReadFile = new ReadFile("../test/readfiletest.txt");
+  }
+  
+  @Test
+  public void fileReadStringArray() throws IOException {
+    try{
+    testStringArray = testReadFile.openFile();
+    }
+    catch (IOException e){
+      System.out.println(e);
+    }
+    String[] correctOutput = {"Line 1","Line 2","Line 3"};
+    assertArrayEquals("Creates String array from readfiletest.txt", correctOutput, testStringArray);
+  }
+}

src/ReadFile.class

@@ -0,0 +1,77 @@
+I cimport java.util.regex.Pattern;
+import java.util.regex.Matcher;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Receipt {
+  private List<Good> goodsList;
+  
+  public Receipt(List<Good> goods) {
+    goodsList = goods;
+  }
+  
+  public List<Good> getList() {
+    return goodsList;
+  }
+  
+  public Good getGood(int index) {
+    Good goodBeforeTax = this.goodsList.get(index);
+    double afterTax;
+    
+    afterTax = goodBeforeTax.getPrice() + getTax(goodBeforeTax);
+    double afterQuantity = afterTax * goodBeforeTax.getQuantity();
+    
+    return new Good(goodBeforeTax.getQuantity(), goodBeforeTax.getName(),afterQuantity);
+  }
+  
+  public double getTotalTax() {
+    double totalTax = 0;
+    
+    for (int i=0;i<goodsList.size();i++) {
+      Good listItem = goodsList.get(i);
+      totalTax += getTax(listItem);
+    }
+    
+    return totalTax;
+  }
+  
+  public double getTotal() {
+    double totalPrice = 0;
+    
+    for (int i=0;i<goodsList.size();i++) {
+      Good listItem = goodsList.get(i);
+      totalPrice += listItem.getPrice();
+    }
+    
+    return totalPrice + getTotalTax();
+  }
+  
+  //The methods below are more like utility methods
+  
+  private double getTax(Good item) {
+    double tax = 0;
+    
+    if (isImported(item.getName())) {
+      tax += (item.getPrice() * 0.05);
+    }
+    
+    if (isTaxable(item.getName())) {
+      tax += (item.getPrice() * 0.10);
+    }
+    
+    tax = (double) Math.ceil(tax*20.0)/20.0;
+    
+    return tax;
+  }
+  
+  private boolean isImported(String name) {
+    return name.contains("imported");
+  }
+  
+  private boolean isTaxable(String name) {
+    Pattern taxExemptKeywords = Pattern.compile("chocolate|pill|book");
+    Matcher hasExemptWords = taxExemptKeywords.matcher(name);
+    
+    return !hasExemptWords.find();
+  }
+}

src/ReadFile.java

@@ -0,0 +1,73 @@
+import static org.junit.Assert.*;
+import org.junit.*;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ReceiptTest {
+  private List<Good> goodsList = new ArrayList<Good>();
+  private Good testGood1;
+  private Good testGood2;
+  private Good testGood3;
+  private Good testGood4;
+  private Receipt testReceipt;
+  
+  @Before
+  public void createReceipt() {
+    testGood1 = new Good(1,"hat",1.00);
+    testGood2 = new Good(1,"imported hat",1.00);
+    testGood3 = new Good(1,"chocolate hat",1.00);
+    testGood4 = new Good(1,"imported chocolate hat",1.00);
+    
+    goodsList.add(testGood1);
+    goodsList.add(testGood2);
+    goodsList.add(testGood3);
+    goodsList.add(testGood4);
+
+    testReceipt = new Receipt(goodsList);
+  }
+  
+  //The different getGoodTests are less-than-ideal because they use methods tested in another area to return values. Ought to be refactored or the attributes exposed via reflection
+
+  @Test
+  public void getGoodTest() {
+    Good item = testReceipt.getGood(0);
+    assertEquals("A hat should be 1.10", 1.10 , item.getPrice() , 0.001);
+    assertEquals("Should have quantity of 1",1,item.getQuantity());
+    assertEquals("Name is hat", "hat", item.getName());
+  }
+  
+  @Test
+  public void getTaxExemptGoodTest() {
+    Good item = testReceipt.getGood(2);
+    assertEquals("A chocolate hat should be 1.00",1.00,item.getPrice(),0.001);
+    assertEquals("Should have quantity of 1",1,item.getQuantity());
+    assertEquals("Name is chocolate hat","chocolate hat",item.getName());
+  }
+  
+  @Test
+  //This method reveals an interesting edge case, there is a very small trailing decimal that causes this method to fail. Need to refactor method in receipt method...
+  public void getImportedGoodTest() {
+    Good item = testReceipt.getGood(1);
+    assertEquals("An imported hat should be 1.15",1.15,item.getPrice(), 0.001);
+    assertEquals("Should have quantity of 1",1,item.getQuantity());
+    assertEquals("Name is imported hat","imported hat",item.getName());
+  }
+  
+  @Test
+  public void getImportedTaxExemptGoodTest() {
+    Good item = testReceipt.getGood(3);
+    assertEquals("A chocolate imported hat should be 1.05",1.05,item.getPrice(), 0.001);
+    assertEquals("Should have quantity of 1",1,item.getQuantity());
+    assertEquals("Name is imported chocolate hat","imported chocolate hat",item.getName());
+  }
+  
+  @Test
+  public void getTotalTaxTest() {
+    assertEquals("Sales tax should be 0.30",0.30,testReceipt.getTotalTax(),0.001);
+  }
+  
+  @Test 
+  public void getTotalTest() {
+    assertEquals("Total price should be 4.35",4.35,testReceipt.getTotal(),0.001);
+  }
+}