tudu 0.0.1 → 0.0.2

data/spec/tudu_core_spec.rb

@@ -1,574 +1,569 @@
-# encoding: utf-8
-require "spec_helper"
-require "tudu_core"
-
-describe Tudu::Core do
-  context :init do
-    cases = [
-      {
-        case_no: 1,
-        case_title: "valid case",
-        expected_files: [
-          Tudu::Tasks::TUDU_FILE, 
-          Tudu::Tasks::TUDU_TODOS_FILE, 
-          Tudu::Tasks::TUDU_DOINGS_FILE, 
-          Tudu::Tasks::TUDU_DONES_FILE
-        ],
-        expected_contents: [
-          Tudu::Tasks::TUDU_FILE_TEMPLATE,
-          Tudu::Tasks::TUDU_TODOS_FILE_TEMPLATE, 
-          Tudu::Tasks::TUDU_DOINGS_FILE_TEMPLATE, 
-          Tudu::Tasks::TUDU_DONES_FILE_TEMPLATE
-        ],
-      },
-    ]
-
-    cases.each do |c|
-      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
-        begin
-          case_before c
-
-          # -- given --
-          tudu_core = Tudu::Core.new
-
-          # -- when --
-          tudu_core.init
-
-          # -- then --
-          c[:expected_files].each_with_index do |f, index|
-            actual = File.open("./tudu/#{f}") {|f|f.read}
-            expect(actual).to eq(c[:expected_contents][index])
-          end
-        ensure
-          case_after c
-        end
-      end
-
-      def case_before(c)
-        # implement each case before
-      end
-
-      def case_after(c)
-        return unless File.exists? "./tudu"
-        FileUtils.rm_rf("./tudu")
-      end
-    end
-  end
-
-  context :add do
-    cases = [
-      {
-        case_no: 1,
-        case_title: "single add",
-        task_names1: "task_name",
-        task_names2: nil,
-        task_names3: nil,
-        expected: ["task_name"]
-      },
-      {
-        case_no: 2,
-        case_title: "nil add",
-        task_names1: nil,
-        task_names2: nil,
-        task_names3: nil,
-        expected: []
-      },
-      {
-        case_no: 3,
-        case_title: "multi add",
-        task_names1: "task_name1",
-        task_names2: "task_name2",
-        task_names3: "task_name3",
-        expected: ["task_name1","task_name2","task_name3"]
-      },
-      {
-        case_no: 4,
-        case_title: "duplicate add",
-        task_names1: "task_name1",
-        task_names2: "task_name1",
-        task_names3: nil,
-        expected: ["task_name1"]
-      },
-    ]
-
-    cases.each do |c|
-      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
-        begin
-          case_before c
-
-          # -- given --
-          tudu_core = Tudu::Core.new
-          tudu_core.init
-
-          # -- when --
-          actual = tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3]
-
-          # -- then --
-          actual = File.read("./tudu/todos").split("\n")
-          expect(actual).to eq(c[:expected])
-        ensure
-          case_after c
-        end
-      end
-
-      def case_before(c)
-        # implement each case before
-      end
-
-      def case_after(c)
-        return unless File.exists? "./tudu"
-        FileUtils.rm_rf("./tudu")
-      end
-    end
-  end
-
-  context :remove do
-    cases = [
-      {
-        case_no: 1,
-        case_title: "single remove",
-        task_names1: "task_name",
-        task_names2: nil,
-        task_names3: nil,
-      },
-      {
-        case_no: 2,
-        case_title: "multi remove",
-        task_names1: "task_name1",
-        task_names2: "task_name2",
-        task_names3: "task_name3",
-      },
-      {
-        case_no: 3,
-        case_title: "not remove",
-        task_names1: "invalid name",
-        task_names2: nil,
-        task_names3: nil,
-      },
-      #  TODO: add doing, done mix case. after implements choose, done method
-    ]
-
-    cases.each do |c|
-      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
-        begin
-          case_before c
-
-          # -- given --
-          tudu_core = Tudu::Core.new
-          tudu_core.init
-          tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3]
-
-          # -- when --
-          tudu_core.remove c[:task_names1], c[:task_names2], c[:task_names3]
-
-          # -- then --
-          [c[:task_names1], c[:task_names2], c[:task_names3]].each do |e|
-            actual = false
-            ["./tudu/todos", "./tudu/doings", "./tudu/dones"].each do |f|
-              actual = true if File.read(f).split("\n").include?(e)
-            end
-            expect(actual).to be_false
-          end
-        ensure
-          case_after c
-        end
-      end
-
-      def case_before(c)
-        # implement each case before
-      end
-
-      def case_after(c)
-        return unless File.exists? "./tudu"
-        FileUtils.rm_rf("./tudu")
-      end
-    end
-  end
-
-  context :tasks do
-    cases = [
-      {
-        case_no: 1,
-        case_title: "[todos, dosings, dones] all tasks",
-        task_names1: "task_name1",
-        task_names2: "task_name2",
-        task_names3: "task_name3",
-        search_word: nil,
-        expected: ["task_name1", "task_name2", "task_name3"]
-      },
-      {
-        case_no: 2,
-        case_title: "[todos, dosings, dones] search specific tasks",
-        task_names1: "task_name1",
-        task_names2: "task_name2",
-        task_names3: "task_name3",
-        search_word: "task_name1",
-        expected: ["task_name1"]
-      },
-      {
-        case_no: 3,
-        case_title: "[todos, dosings, dones] search specific tasks by regexp",
-        task_names1: "task_name1_1",
-        task_names2: "task_name2_1",
-        task_names3: "task_name2_2",
-        task_names4: "task_name3_1",
-        search_word: "task_name2_",
-        expected: ["task_name2_1", "task_name2_2"]
-      },
-      #  TODO: add doing, done mix case. after implements choose, done method
-    ]
-
-    cases.each do |c|
-      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
-        begin
-          case_before c
-
-          # -- given --
-          tudu_core = Tudu::Core.new
-          tudu_core.init
-          tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3], c[:task_names4]
-
-          # -- when --
-          actual = tudu_core.tasks c[:search_word]
-
-          # -- then --
-          expect(actual).to eq(c[:expected])
-        ensure
-          case_after c
-        end
-      end
-
-      def case_before(c)
-        # implement each case before
-      end
-
-      def case_after(c)
-        return unless File.exists? "./tudu"
-        FileUtils.rm_rf("./tudu")
-      end
-    end
-  end
-
-  context :todos do
-    cases = [
-      {
-        case_no: 1,
-        case_title: "todos all tasks",
-        task_names1: "task_name1",
-        task_names2: "task_name2",
-        task_names3: "task_name3",
-        choose: true,
-        choose_name: "task_name1",
-        search_word: nil,
-        expected: ["task_name2", "task_name3"]
-      },
-      {
-        case_no: 2,
-        case_title: "todos search specific tasks",
-        task_names1: "task_name1",
-        task_names2: "task_name2",
-        task_names3: "task_name3",
-        choose: true,
-        choose_name: "task_name1",
-        search_word: "task_name3",
-        expected: ["task_name3"]
-      },
-      {
-        case_no: 3,
-        case_title: "todos search specific tasks by regexp",
-        task_names1: "task_name1_1",
-        task_names2: "task_name2_1",
-        task_names3: "task_name2_2",
-        task_names4: "task_name3_1",
-        choose: true,
-        choose_name: "task_name1_1",
-        search_word: "task_name2_",
-        expected: ["task_name2_1", "task_name2_2"]
-      },
-    ]
-
-    cases.each do |c|
-      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
-        begin
-          case_before c
-
-          # -- given --
-          tudu_core = Tudu::Core.new
-          tudu_core.init
-          tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3], c[:task_names4]
-          tudu_core.choose(c[:choose_name]) if c[:choose]
-
-          # -- when --
-          actual = tudu_core.todos c[:search_word]
-
-          # -- then --
-          expect(actual).to eq(c[:expected])
-        ensure
-          case_after c
-        end
-      end
-
-      def case_before(c)
-        # implement each case before
-      end
-
-      def case_after(c)
-        # implement each case after
-        return unless File.exists? "./tudu"
-        FileUtils.rm_rf("./tudu")
-      end
-    end
-  end
-
-  context :doings do
-    cases = [
-      {
-        case_no: 1,
-        case_title: "doings all tasks",
-        task_names1: "task_name1",
-        task_names2: "task_name2",
-        task_names3: "task_name3",
-        choose: true,
-        choose_name: "task_name1",
-        search_word: nil,
-        expected: ["task_name1"]
-      },
-      {
-        case_no: 2,
-        case_title: "doings search specific tasks",
-        task_names1: "task_name1",
-        task_names2: "task_name2",
-        task_names3: "task_name3",
-        choose: true,
-        choose_name: "task_name1",
-        search_word: nil,
-        expected: ["task_name1"]
-      },
-      {
-        case_no: 3,
-        case_title: "doings search specific tasks by regexp",
-        task_names1: "task_name1_1",
-        task_names2: "task_name2_1",
-        task_names3: "task_name2_2",
-        task_names4: "task_name3_1",
-        choose: true,
-        choose_name: "task_name1_1",
-        search_word: "task_name1_",
-        expected: ["task_name1_1"]
-      },
-    ]
-
-    cases.each do |c|
-      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
-        begin
-          case_before c
-
-          # -- given --
-          tudu_core = Tudu::Core.new
-          tudu_core.init
-          tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3], c[:task_names4]
-          tudu_core.choose(c[:choose_name]) if c[:choose]
-
-          # -- when --
-          actual = tudu_core.doings c[:search_word]
-
-          # -- then --
-          expect(actual).to eq(c[:expected])
-        ensure
-          case_after c
-        end
-      end
-
-      def case_before(c)
-        # implement each case before
-      end
-
-      def case_after(c)
-        # implement each case after
-        return unless File.exists? "./tudu"
-        FileUtils.rm_rf("./tudu")
-      end
-    end
-  end
-
-  context :dones do
-    cases = [
-      {
-        case_no: 1,
-        case_title: "doings all tasks",
-        task_names1: "task_name1",
-        task_names2: "task_name2",
-        task_names3: "task_name3",
-        choose_names: ["task_name1", "task_name2"],
-        done_names: ["task_name1"],
-        search_word: nil,
-        expected: ["task_name1"]
-      },
-      {
-        case_no: 2,
-        case_title: "doings search specific tasks",
-        task_names1: "task_name1_1",
-        task_names2: "task_name1_2",
-        task_names3: "task_name2_1",
-        choose_names: ["task_name1_1", "task_name1_2", "task_name2_1"],
-        done_names: ["task_name1_1", "task_name1_2", "task_name2_1"],
-        search_word: "task_name1_",
-        expected: ["task_name1_1", "task_name1_2"]
-      },
-    ]
-
-    cases.each do |c|
-      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
-        begin
-          case_before c
-
-          # -- given --
-          tudu_core = Tudu::Core.new
-          tudu_core.init
-          tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3], c[:task_names4]
-          c[:choose_names].each do |e|
-            tudu_core.choose e
-            tudu_core.done if c[:done_names].include? e
-          end
-
-          # -- when --
-          actual = tudu_core.dones c[:search_word]
-
-          # -- then --
-          expect(actual).to eq(c[:expected])
-        ensure
-          case_after c
-        end
-      end
-
-      def case_before(c)
-        # implement each case before
-      end
-
-      def case_after(c)
-        # implement each case after
-        return unless File.exists? "./tudu"
-        FileUtils.rm_rf("./tudu")
-      end
-    end
-  end
-
-  context :choose do
-    cases = [
-      {
-        case_no: 1,
-        case_title: "choose task",
-        task_names1: "task_name1",
-        task_names2: "task_name2",
-        task_names3: "task_name3",
-        choose: "task_name1",
-        expected_todos: "task_name2\ntask_name3\n",
-        expected_doings: "task_name1\n"
-      },
-      # doingにデータがあるケース
-      # すでにdoingのケース
-      # すでにdoneのケース
-      # 存在しないケース
-    ]
-
-    cases.each do |c|
-      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
-        begin
-          case_before c
-
-          # -- given --
-          tudu_core = Tudu::Core.new
-          tudu_core.init
-          tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3]
-
-          # -- when --
-          tudu_core.choose c[:choose]
-
-          # -- then --
-          actual_doings = File.read("./tudu/#{Tudu::Tasks::TUDU_DOINGS_FILE}")
-          expect(actual_doings).to eq(c[:expected_doings])
-          actual_todos = File.read("./tudu/#{Tudu::Tasks::TUDU_TODOS_FILE}")
-          expect(actual_todos).to eq(c[:expected_todos])
-        ensure
-          case_after c
-        end
-      end
-
-      def case_before(c)
-        # implement each case before
-      end
-
-      def case_after(c)
-        # implement each case after
-        return unless File.exists? "./tudu"
-        FileUtils.rm_rf("./tudu")
-      end
-    end
-  end
-
-  context :done do
-    cases = [
-      {
-        case_no: 1,
-        case_title: "one doing to done, shift todo to doing",
-        task_names1: "task_name1",
-        task_names2: "task_name2",
-        task_names3: "task_name3",
-        choose: "task_name1",
-        expected_doings: "task_name2\n",
-        expected_done: "task_name1\n"
-      },
-      {
-        case_no: 2,
-        case_title: "one doing to done, not shift todo to doing",
-        task_names1: "task_name1",
-        choose: "task_name1",
-        expected_doings: "",
-        expected_done: "task_name1\n"
-      },
-      {
-        case_no: 3,
-        case_title: "no doing",
-        task_names1: "task_name1",
-        choose: "",
-        expected_doings: "",
-        expected_done: ""
-      },
-    ]
-
-    cases.each do |c|
-      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
-        begin
-          case_before c
-
-          # -- given --
-          tudu_core = Tudu::Core.new
-          tudu_core.init
-          tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3]
-          tudu_core.choose c[:choose]
-
-          # -- when --
-          tudu_core.done
-
-          # -- then --
-          actual_doings = File.read(Tudu::Tasks::TUDU_DOINGS_FILE_PATH)
-          expect(actual_doings).to eq(c[:expected_doings])
-          actual_dones = File.read(Tudu::Tasks::TUDU_DONES_FILE_PATH)
-          expect(actual_dones).to eq(c[:expected_done])
-        ensure
-          case_after c
-        end
-      end
-
-      def case_before(c)
-        # implement each case before
-      end
-
-      def case_after(c)
-        # implement each case after
-        return unless File.exists? "./tudu"
-        FileUtils.rm_rf("./tudu")
-      end
-    end
-  end
-end
+# encoding: utf-8
+require "spec_helper"
+require "tudu_core"
+
+describe Tudu::Core do
+  context :init do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "valid case",
+        expected_files: [
+          Tudu::Tasks::TUDU_FILE, 
+          Tudu::Tasks::TUDU_TODOS_FILE, 
+          Tudu::Tasks::TUDU_DOINGS_FILE, 
+          Tudu::Tasks::TUDU_DONES_FILE
+        ],
+        expected_contents: [
+          Tudu::Tasks::TUDU_FILE_TEMPLATE,
+          Tudu::Tasks::TUDU_TODOS_FILE_TEMPLATE, 
+          Tudu::Tasks::TUDU_DOINGS_FILE_TEMPLATE, 
+          Tudu::Tasks::TUDU_DONES_FILE_TEMPLATE
+        ],
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          tudu_core = Tudu::Core.new
+
+          # -- when --
+          tudu_core.init
+
+          # -- then --
+          c[:expected_files].each_with_index do |f, index|
+            actual = File.open("./tudu/#{f}") {|f|f.read}
+            expect(actual).to eq(c[:expected_contents][index])
+          end
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        return unless File.exists? "./tudu"
+        FileUtils.rm_rf("./tudu")
+      end
+    end
+  end
+
+  context :add do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "single add",
+        task_names1: "task_name",
+        task_names2: nil,
+        task_names3: nil,
+        expected: ["task_name"]
+      },
+      {
+        case_no: 2,
+        case_title: "nil add",
+        task_names1: nil,
+        task_names2: nil,
+        task_names3: nil,
+        expected: []
+      },
+      {
+        case_no: 3,
+        case_title: "multi add",
+        task_names1: "task_name1",
+        task_names2: "task_name2",
+        task_names3: "task_name3",
+        expected: ["task_name1","task_name2","task_name3"]
+      },
+      {
+        case_no: 4,
+        case_title: "duplicate add",
+        task_names1: "task_name1",
+        task_names2: "task_name1",
+        task_names3: nil,
+        expected: ["task_name1"]
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          tudu_core = Tudu::Core.new
+          tudu_core.init
+
+          # -- when --
+          actual = tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3]
+
+          # -- then --
+          actual = File.read("./tudu/todos").split("\n")
+          expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        return unless File.exists? "./tudu"
+        FileUtils.rm_rf("./tudu")
+      end
+    end
+  end
+
+  context :remove do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "single remove",
+        task_names1: "task_name",
+        task_names2: nil,
+        task_names3: nil,
+      },
+      {
+        case_no: 2,
+        case_title: "multi remove",
+        task_names1: "task_name1",
+        task_names2: "task_name2",
+        task_names3: "task_name3",
+      },
+      {
+        case_no: 3,
+        case_title: "not remove",
+        task_names1: "invalid name",
+        task_names2: nil,
+        task_names3: nil,
+      },
+      #  TODO: add doing, done mix case. after implements choose, done method
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          tudu_core = Tudu::Core.new
+          tudu_core.init
+          tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3]
+
+          # -- when --
+          tudu_core.remove c[:task_names1], c[:task_names2], c[:task_names3]
+
+          # -- then --
+          [c[:task_names1], c[:task_names2], c[:task_names3]].each do |e|
+            actual = false
+            ["./tudu/todos", "./tudu/doings", "./tudu/dones"].each do |f|
+              actual = true if File.read(f).split("\n").include?(e)
+            end
+            expect(actual).to be_false
+          end
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        return unless File.exists? "./tudu"
+        FileUtils.rm_rf("./tudu")
+      end
+    end
+  end
+
+  context :tasks do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "[todos, dosings, dones] all tasks",
+        task_names1: "task_name1",
+        task_names2: "task_name2",
+        task_names3: "task_name3",
+        search_word: nil,
+        expected: ["task_name1", "task_name2", "task_name3"]
+      },
+      {
+        case_no: 2,
+        case_title: "[todos, dosings, dones] search specific tasks",
+        task_names1: "task_name1",
+        task_names2: "task_name2",
+        task_names3: "task_name3",
+        search_word: "task_name1",
+        expected: ["task_name1"]
+      },
+      {
+        case_no: 3,
+        case_title: "[todos, dosings, dones] search specific tasks by regexp",
+        task_names1: "task_name1_1",
+        task_names2: "task_name2_1",
+        task_names3: "task_name2_2",
+        task_names4: "task_name3_1",
+        search_word: "task_name2_",
+        expected: ["task_name2_1", "task_name2_2"]
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          tudu_core = Tudu::Core.new
+          tudu_core.init
+          tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3], c[:task_names4]
+
+          # -- when --
+          actual = tudu_core.tasks c[:search_word]
+
+          # -- then --
+          expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        return unless File.exists? "./tudu"
+        FileUtils.rm_rf("./tudu")
+      end
+    end
+  end
+
+  context :todos do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "todos all tasks",
+        task_names1: "task_name1",
+        task_names2: "task_name2",
+        task_names3: "task_name3",
+        choose: true,
+        choose_name: "task_name1",
+        search_word: nil,
+        expected: ["task_name2", "task_name3"]
+      },
+      {
+        case_no: 2,
+        case_title: "todos search specific tasks",
+        task_names1: "task_name1",
+        task_names2: "task_name2",
+        task_names3: "task_name3",
+        choose: true,
+        choose_name: "task_name1",
+        search_word: "task_name3",
+        expected: ["task_name3"]
+      },
+      {
+        case_no: 3,
+        case_title: "todos search specific tasks by regexp",
+        task_names1: "task_name1_1",
+        task_names2: "task_name2_1",
+        task_names3: "task_name2_2",
+        task_names4: "task_name3_1",
+        choose: true,
+        choose_name: "task_name1_1",
+        search_word: "task_name2_",
+        expected: ["task_name2_1", "task_name2_2"]
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          tudu_core = Tudu::Core.new
+          tudu_core.init
+          tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3], c[:task_names4]
+          tudu_core.choose(c[:choose_name]) if c[:choose]
+
+          # -- when --
+          actual = tudu_core.todos c[:search_word]
+
+          # -- then --
+          expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+        return unless File.exists? "./tudu"
+        FileUtils.rm_rf("./tudu")
+      end
+    end
+  end
+
+  context :doings do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "doings all tasks",
+        task_names1: "task_name1",
+        task_names2: "task_name2",
+        task_names3: "task_name3",
+        choose: true,
+        choose_name: "task_name1",
+        search_word: nil,
+        expected: ["task_name1"]
+      },
+      {
+        case_no: 2,
+        case_title: "doings search specific tasks",
+        task_names1: "task_name1",
+        task_names2: "task_name2",
+        task_names3: "task_name3",
+        choose: true,
+        choose_name: "task_name1",
+        search_word: nil,
+        expected: ["task_name1"]
+      },
+      {
+        case_no: 3,
+        case_title: "doings search specific tasks by regexp",
+        task_names1: "task_name1_1",
+        task_names2: "task_name2_1",
+        task_names3: "task_name2_2",
+        task_names4: "task_name3_1",
+        choose: true,
+        choose_name: "task_name1_1",
+        search_word: "task_name1_",
+        expected: ["task_name1_1"]
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          tudu_core = Tudu::Core.new
+          tudu_core.init
+          tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3], c[:task_names4]
+          tudu_core.choose(c[:choose_name]) if c[:choose]
+
+          # -- when --
+          actual = tudu_core.doings c[:search_word]
+
+          # -- then --
+          expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+        return unless File.exists? "./tudu"
+        FileUtils.rm_rf("./tudu")
+      end
+    end
+  end
+
+  context :dones do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "doings all tasks",
+        task_names1: "task_name1",
+        task_names2: "task_name2",
+        task_names3: "task_name3",
+        choose_names: ["task_name1", "task_name2"],
+        done_names: ["task_name1"],
+        search_word: nil,
+        expected: ["task_name1"]
+      },
+      {
+        case_no: 2,
+        case_title: "doings search specific tasks",
+        task_names1: "task_name1_1",
+        task_names2: "task_name1_2",
+        task_names3: "task_name2_1",
+        choose_names: ["task_name1_1", "task_name1_2", "task_name2_1"],
+        done_names: ["task_name1_1", "task_name1_2", "task_name2_1"],
+        search_word: "task_name1_",
+        expected: ["task_name1_1", "task_name1_2"]
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          tudu_core = Tudu::Core.new
+          tudu_core.init
+          tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3], c[:task_names4]
+          c[:choose_names].each do |e|
+            tudu_core.choose e
+            tudu_core.done if c[:done_names].include? e
+          end
+
+          # -- when --
+          actual = tudu_core.dones c[:search_word]
+
+          # -- then --
+          expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+        return unless File.exists? "./tudu"
+        FileUtils.rm_rf("./tudu")
+      end
+    end
+  end
+
+  context :choose do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "choose task",
+        task_names1: "task_name1",
+        task_names2: "task_name2",
+        task_names3: "task_name3",
+        choose: "task_name1",
+        expected_todos: "task_name2\ntask_name3\n",
+        expected_doings: "task_name1\n"
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          tudu_core = Tudu::Core.new
+          tudu_core.init
+          tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3]
+
+          # -- when --
+          tudu_core.choose c[:choose]
+
+          # -- then --
+          actual_doings = File.read("./tudu/#{Tudu::Tasks::TUDU_DOINGS_FILE}")
+          expect(actual_doings).to eq(c[:expected_doings])
+          actual_todos = File.read("./tudu/#{Tudu::Tasks::TUDU_TODOS_FILE}")
+          expect(actual_todos).to eq(c[:expected_todos])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+        return unless File.exists? "./tudu"
+        FileUtils.rm_rf("./tudu")
+      end
+    end
+  end
+
+  context :done do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "one doing to done, shift todo to doing",
+        task_names1: "task_name1",
+        task_names2: "task_name2",
+        task_names3: "task_name3",
+        choose: "task_name1",
+        expected_doings: "task_name2\n",
+        expected_done: "task_name1\n"
+      },
+      {
+        case_no: 2,
+        case_title: "one doing to done, not shift todo to doing",
+        task_names1: "task_name1",
+        choose: "task_name1",
+        expected_doings: "",
+        expected_done: "task_name1\n"
+      },
+      {
+        case_no: 3,
+        case_title: "no doing",
+        task_names1: "task_name1",
+        choose: "",
+        expected_doings: "",
+        expected_done: ""
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          tudu_core = Tudu::Core.new
+          tudu_core.init
+          tudu_core.add c[:task_names1], c[:task_names2], c[:task_names3]
+          tudu_core.choose c[:choose] unless c[:choose].empty?
+
+          # -- when --
+          tudu_core.done
+
+          # -- then --
+          actual_doings = File.read(Tudu::Tasks::TUDU_DOINGS_FILE_PATH)
+          expect(actual_doings).to eq(c[:expected_doings])
+          actual_dones = File.read(Tudu::Tasks::TUDU_DONES_FILE_PATH)
+          expect(actual_dones).to eq(c[:expected_done])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+        return unless File.exists? "./tudu"
+        FileUtils.rm_rf("./tudu")
+      end
+    end
+  end
+end