money_tracking 0.99.0

data/spec/money_tracking/cli/create_command_spec.rb

@@ -0,0 +1,38 @@
+module MoneyTracking
+  module Cli
+    RSpec.describe CreateCommand do
+      subject { described_class.new(expense_factory, "79.5", "euro", ["food", "other"]) }
+
+      let(:expense_factory) { instance_double(Domain::ExpenseFactory) }
+      let(:expense) { instance_double(Domain::Expense, build_view: nil) }
+      let(:view) { instance_double(Views::ExpenseCreated) }
+
+      before do
+        allow(expense_factory)
+          .to receive(:create).with(
+                amount: 79.5,
+                currency: "euro",
+                tags: ["food", "other"],
+              ).and_return(expense)
+      end
+
+      it "creates an expense object" do
+        expect(expense_factory)
+          .to receive(:create).with(
+                amount: 79.5,
+                currency: "euro",
+                tags: ["food", "other"],
+              ).and_return(expense)
+        subject.call
+      end
+
+      it "renders ExpenseCreated view" do
+        allow(expense)
+          .to receive(:build_view)
+               .with(Views::ExpenseCreated)
+               .and_return(view)
+        expect(subject.call).to eq(view)
+      end
+    end
+  end
+end

data/spec/money_tracking/cli/delete_command_spec.rb

@@ -0,0 +1,44 @@
+module MoneyTracking
+  module Cli
+    RSpec.describe DeleteCommand do
+      subject { described_class.new(expense_finder, expense_id) }
+
+      let(:expense_finder) { instance_double(Domain::ExpenseFinder) }
+      let(:expense_id) { "ja6ptd3d" }
+      let(:expense) { instance_double(Domain::Expense) }
+      let(:not_found) { instance_double(Domain::ExpenseNotFound) }
+      let(:view) { instance_double(Views::ExpenseDeleted) }
+      let(:not_found_view) { instance_double(Views::ExpenseNotFound) }
+
+      before do
+        allow(expense).to receive(:build_view).with(Views::ExpenseDeleted).and_return(view)
+        allow(expense).to receive(:delete).and_return(expense)
+
+        allow(not_found).to receive(:build_view).with(Views::ExpenseDeleted)
+                             .and_return(not_found_view)
+        allow(not_found).to receive(:delete).and_return(not_found)
+      end
+
+      context "when no such expense found" do
+        before { allow(expense_finder).to receive(:read).with(expense_id).and_return(not_found) }
+
+        it "returns ExpenseNotFound view" do
+          expect(subject.call).to be(not_found_view)
+        end
+      end
+
+      context "when expense was found" do
+        before { allow(expense_finder).to receive(:read).with(expense_id).and_return(expense) }
+
+        it "returns ExpenseDeleted view" do
+          expect(subject.call).to be(view)
+        end
+
+        it "deletes an expense" do
+          expect(expense).to receive(:delete)
+          subject.call
+        end
+      end
+    end
+  end
+end

data/spec/money_tracking/cli/list_command_spec.rb

@@ -0,0 +1,34 @@
+module MoneyTracking
+  module Cli
+    RSpec.describe ListCommand do
+      subject { described_class.new(expense_finder) }
+
+      let(:view) { double("View") }
+      let(:expense_finder) { instance_double(Domain::ExpenseFinder) }
+      let(:expenses) { [expense_a, expense_b] }
+
+      let(:expense_a) { instance_double(Domain::Expense) }
+      let(:expense_b) { instance_double(Domain::Expense) }
+
+      context "when there are no expenses" do
+        before { allow(expense_finder).to receive(:list).and_return([]) }
+
+        it "returns empty view" do
+          expect(subject.call).to be_a(Views::Empty)
+        end
+      end
+
+      context "when there are some expenses" do
+        before { allow(expense_finder).to receive(:list).and_return(expenses) }
+
+        it "creates proper expense list view and returns it" do
+          allow(Views::ExpenseList)
+            .to receive(:new)
+                 .with(expenses, Views::ExpenseItem)
+                 .and_return(view)
+          expect(subject.call).to be(view)
+        end
+      end
+    end
+  end
+end

data/spec/money_tracking/cli/update_command_spec.rb

@@ -0,0 +1,92 @@
+module MoneyTracking
+  module Cli
+    RSpec.describe UpdateCommand do
+      subject { described_class.new(
+        expense_finder,
+        id,
+        amount,
+        currency,
+        add_tags,
+        rm_tags,
+      ) }
+
+      let(:expense_finder) { instance_double(Domain::ExpenseFinder) }
+      let(:not_found) { instance_double(Domain::ExpenseNotFound) }
+      let(:not_found_view) { instance_double(Views::ExpenseNotFound) }
+
+      let(:view) { instance_double(Views::ExpenseUpdated) }
+      let(:not_updated_view) { instance_double(Views::ExpenseNotUpdated) }
+
+      let(:id) { "8ti0osfb" }
+      let(:amount) { nil }
+      let(:currency) { nil }
+      let(:add_tags) { nil }
+      let(:rm_tags) { nil }
+
+      before { allow(not_found).to receive(:update).and_return(not_found) }
+
+      context "when expense is not found" do
+        before { allow(expense_finder).to receive(:read).with(id).and_return(not_found) }
+
+        it "renders not found view" do
+          allow(not_found)
+            .to receive(:build_view)
+                 .and_return(not_found_view)
+          expect(subject.call).to be(not_found_view)
+        end
+      end
+
+      context "when expense is found" do
+        let(:expense) { instance_double(Domain::Expense) }
+
+        before do
+          allow(expense_finder).to receive(:read).with(id).and_return(expense)
+          allow(expense).to receive(:update).and_return(expense)
+
+          allow(expense)
+            .to receive(:build_view)
+                 .with(Views::ExpenseUpdated)
+                 .and_return(view)
+
+          allow(expense)
+            .to receive(:build_view)
+                 .with(Views::ExpenseNotUpdated)
+                 .and_return(not_updated_view)
+        end
+
+        context "when there are no other options provided" do
+          it "does nothing" do
+            subject.call
+          end
+
+          it "renders ExpenseNotUpdated view" do
+            expect(subject.call).to be(not_updated_view)
+          end
+        end
+
+        context "when there was some options provided" do
+          let(:amount) { 94.5 }
+          let(:currency) { "dollar" }
+          let(:add_tags) { ["food", "drinks"] }
+          let(:rm_tags) { ["dinner"] }
+
+          it "delegates to model's #update" do
+            expect(expense)
+              .to receive(:update)
+                   .with(
+                     amount: amount,
+                     currency: currency,
+                     add_tags: add_tags,
+                     rm_tags: rm_tags,
+                   ).and_return(expense)
+            subject.call
+          end
+
+          it "returns ExpenseUpdated view" do
+            expect(subject.call).to be(view)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/money_tracking/cli/views/expense_item_spec.rb

@@ -0,0 +1,60 @@
+module MoneyTracking
+  module Cli
+    module Views
+      RSpec.describe ExpenseItem do
+        subject(:view) {
+          described_class.new(
+            id: id,
+            created_at: created_at,
+            amount: amount,
+            currency: currency,
+            tags: tags,
+          )
+        }
+
+        let(:id) { "go5775ft" }
+        let(:created_at) { "14-04-2015 17:03:25" }
+        let(:amount) { 47.39 }
+        let(:currency) { "dollar" }
+        let(:tags) { ["other"] }
+
+        it "returns proper string representation" do
+          expect(view.to_s)
+            .to eq("go5775ft - 14-04-2015 17:03:25: 47.39 dollar [other]")
+        end
+
+        context "when number has more than 2 decimals after floating point" do
+          let(:amount) { 33.9876 }
+          it "rounds everything after 2 first decimals" do
+            expect(view.to_s)
+              .to eq("go5775ft - 14-04-2015 17:03:25: 33.99 dollar [other]")
+          end
+        end
+
+        context "when number has less than 2 decimals after floating point" do
+          let(:amount) { 33.7 }
+          it "pads with zeros up to 2 decimals" do
+            expect(view.to_s)
+              .to eq("go5775ft - 14-04-2015 17:03:25: 33.70 dollar [other]")
+          end
+        end
+
+        context "when there are no tags" do
+          let(:tags) { [] }
+          it "does not render them" do
+            expect(view.to_s)
+              .to eq("go5775ft - 14-04-2015 17:03:25: 47.39 dollar")
+          end
+        end
+
+        context "when there are more tags" do
+          let(:tags) { ["other", "food", "pricey"] }
+          it "does render them in sorted order" do
+            expect(view.to_s)
+              .to eq("go5775ft - 14-04-2015 17:03:25: 47.39 dollar [food other pricey]")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/money_tracking/cli/views/expense_list_spec.rb

@@ -0,0 +1,40 @@
+module MoneyTracking
+  module Cli
+    module Views
+      RSpec.describe ExpenseList do
+        subject(:view) {
+          described_class.new(
+            expenses,
+            item_factory,
+          )
+        }
+
+        let(:expenses) { [expense_a, expense_b, expense_c] }
+        let(:item_factory) { class_double(ExpenseItem) }
+
+        let(:expense_a) { instance_double(Domain::Expense) }
+        let(:expense_b) { instance_double(Domain::Expense) }
+        let(:expense_c) { instance_double(Domain::Expense) }
+
+        let(:item_a) { double("Item expense a", to_s: "an item a") }
+        let(:item_b) { double("Item expense b", to_s: "an item b") }
+        let(:item_c) { double("Item expense c", to_s: "an item c") }
+
+        before do
+          allow(expense_a).to receive(:build_view).with(item_factory).and_return(item_a)
+          allow(expense_b).to receive(:build_view).with(item_factory).and_return(item_b)
+          allow(expense_c).to receive(:build_view).with(item_factory).and_return(item_c)
+        end
+
+        it "renders proper list" do
+          expect(view.to_s.split("\n"))
+            .to eq([
+                     "an item a",
+                     "an item b",
+                     "an item c",
+                   ])
+        end
+      end
+    end
+  end
+end

data/spec/money_tracking/data_store/acts_as_a_data_store.rb

@@ -0,0 +1,144 @@
+require "set"
+
+RSpec.shared_context "acts as a DataStore" do |options|
+  store_reset = options.fetch(:store_reset, -> {})
+
+  before { store_reset.call }
+  after { store_reset.call }
+
+  shared_examples "returns nil" do
+    it "returns nil" do
+      is_expected.to eq(nil)
+    end
+  end
+
+  shared_examples "returns empty record set" do
+    it "returns empty record set" do
+      is_expected.to be_empty
+    end
+  end
+
+  describe "#create" do
+    subject { store.create(fields) }
+    let(:fields) { { hello: "world", test: 35, some: [1, 2, "3"] } }
+
+    it "returns unique id of created record" do
+      is_expected.to match(/^[\d\w]{8}$/)
+    end
+  end
+
+  describe "#read" do
+    subject { store.read(id) }
+    let(:id) { "some id" }
+
+    context "when there was some records created" do
+      let(:fields_a) { { hello: "world", test: 99 } }
+      let(:fields_b) { { crazy: "stuff", amount: 89.5, tags: ["hello", "world"] } }
+      let(:fields_c) { { lonely: "field" } }
+
+      let!(:id_a) { store.create(fields_a) }
+      let!(:id_b) { store.create(fields_b) }
+      let!(:id_c) { store.create(fields_c) }
+
+      let(:id) { id_b }
+
+      it "returns fields of the record with specified id" do
+        is_expected.to eq(fields_b.merge(id: id_b))
+      end
+
+      context "but record with specified id doesn't exist" do
+        let(:id) { "other id" }
+
+        include_examples "returns nil"
+      end
+
+      context "and was deleted afterwards" do
+        before { store.delete(id) }
+
+        include_examples "returns nil"
+      end
+
+      context "and was updated with new fields" do
+        before { store.update(id, new_fields) }
+
+        let(:new_fields) { fields_b.merge(amount: 44, hello: "world") }
+
+        it "returns updated fields of the record with specified id" do
+          is_expected.to eq(new_fields.merge(id: id_b))
+        end
+      end
+    end
+
+    context "when record wasn't created" do
+      include_examples "returns nil"
+    end
+  end
+
+  describe "#list" do
+    subject { store.list.to_set }
+
+    context "when there was no record created" do
+      include_examples "returns empty record set"
+    end
+
+    context "when there was some records created" do
+      let(:fields_a) { { hello: "world", test: 99 } }
+      let(:fields_b) { { crazy: "stuff", amount: 89.5, tags: ["hello", "world"] } }
+      let(:fields_c) { { lonely: "field" } }
+      let(:fields_d) { { user: 79, name: "john" } }
+
+      let!(:id_a) { store.create(fields_a) }
+      let!(:id_b) { store.create(fields_b) }
+      let!(:id_c) { store.create(fields_c) }
+      let!(:id_d) { store.create(fields_d) }
+
+      let(:final_a) { fields_a.merge(id: id_a) }
+      let(:final_b) { fields_b.merge(id: id_b) }
+      let(:final_c) { fields_c.merge(id: id_c) }
+      let(:final_d) { fields_d.merge(id: id_d) }
+
+      it "returns all these records" do
+        is_expected.to eq([final_a, final_b, final_c, final_d].to_set)
+      end
+
+      context "and some records were updated" do
+        before do
+          store.update(id_a, new_fields_a)
+          store.update(id_c, new_fields_c)
+        end
+
+        let(:new_fields_a) { fields_a.merge(lazy: "programmer", pragmatic: "programmer") }
+        let(:new_fields_c) { fields_c.merge(amount: 44, hello: "world") }
+
+        let(:new_final_a) { new_fields_a.merge(id: id_a) }
+        let(:new_final_c) { new_fields_c.merge(id: id_c) }
+
+        it "returns all these records with updated fields" do
+          is_expected.to eq([new_final_a, final_b, new_final_c, final_d].to_set)
+        end
+      end
+
+      context "and some records were deleted" do
+        before do
+          store.delete(id_b)
+          store.delete(id_c)
+        end
+
+        it "returns all the records that are left" do
+          is_expected.to eq([final_a, final_d].to_set)
+        end
+      end
+
+      context "and all records were deleted" do
+        before do
+          store.delete(id_a)
+          store.delete(id_b)
+          store.delete(id_c)
+          store.delete(id_d)
+        end
+
+        include_examples "returns empty record set"
+      end
+    end
+  end
+end