ankit 0.0.0

data/test/command_test.rb

@@ -0,0 +1,406 @@
+
+require 'ankit/runtime'
+
+require 'test/unit'
+require 'fileutils'
+require 'tmpdir'
+require 'mocha'
+
+class CommandTest < Test::Unit::TestCase
+  include Ankit
+
+  def test_available
+    assert(Command::COMMANDS.include?(HelloCommand))
+  end
+
+  def test_command_names
+    assert_equal(Command.by_name["hello"], HelloCommand)
+  end
+end
+
+class ListTest <  Test::Unit::TestCase
+  include Ankit
+  include Ankit::TestHelper
+
+  def test_hello
+    lines = make_runtime.dispatch_then(["hello"]).printed_lines
+    a_subpath = File.join(HELLO_REPO, "cards", "foo")
+    assert(lines.include?("card_search_paths: #{a_subpath}"))
+  end
+
+  def test_list
+    lines = make_runtime.dispatch_then(["list"]).printed_lines
+    assert( lines.include?(File.join(HELLO_REPO, "cards", "foo", "hello.card")))
+    assert(!lines.include?(File.join(HELLO_REPO, "cards", "foo")))
+    not_a_card = File.join(HELLO_REPO, "cards", "foo", "this_is_not_a_card.txt")
+    assert( File.file?(not_a_card))
+    assert(!lines.include?(not_a_card))
+  end
+end
+
+class FindTest < Test::Unit::TestCase
+  include Ankit
+  include Ankit::TestHelper
+
+  def test_hello
+    assert_equal(make_runtime.dispatch_then(["find", "vanilla-please", "hello", "no-such-card"]).printed_lines, 
+                 [repo_data_at("cards/foo/vanilla-please.card"),
+                  repo_data_at("cards/foo/hello.card")])
+  end
+end
+
+class NameTest <  Test::Unit::TestCase
+  include Ankit
+  include Ankit::TestHelper
+
+  def test_bad_options
+    assert_raise(BadOptions) do
+      target = make_runtime
+      target.dispatch(["name", "--stdin", "hello"])
+    end
+
+    assert_raise(BadOptions) do
+      target = make_runtime
+      target.dispatch(["name"])
+    end
+  end
+
+  def test_stdin
+    target = make_runtime
+    target.stdin.string << "O: Hello!\n\n"
+    assert_equal(target.dispatch_then(["name", "--stdin"]).printed_line, "hello")
+  end
+
+  def test_hello
+    target = make_runtime
+    target.dispatch(["name", test_data_at("hello_card.card"), test_data_at("bye_card.card")])
+    assert_equal(target.printed_lines, ["hello-world", "bye-universe"])
+  end
+end
+
+class ScoreTest < Test::Unit::TestCase
+  include Ankit
+  include Ankit::TestHelper
+
+  def test_each_event
+    target = ScoreCommand.new(make_runtime, [])
+    all = target.to_enum(:each_event).to_a
+    assert_equal(all.size, 4)
+    assert_equal(all[0].class, Event)
+    assert_equal(target.to_enum(:each_event, "hello").to_a.size, 2)
+  end
+
+  def test_hello
+    target = make_runtime
+    target.dispatch(["score", repo_data_at("to_cards/foo/hello.card")])
+    assert_equal(2, target.printed_lines.size)
+  end
+
+  def test_find_dup
+    target = make_runtime
+    latest = EventTraversing.find_latest_event_for(target, repo_data_at("to_cards/foo/hello.card"))
+    assert_equal(latest.round, 6)
+  end
+end
+
+
+class RoundTest < Test::Unit::TestCase
+  include Ankit
+  include Ankit::TestHelper
+
+  def test_hello
+    assert_equal(make_runtime.dispatch_then(["round"]).printed_line, "6 9")
+  end
+
+  def test_vanilla
+    assert_equal(make_vanilla_runtime.dispatch_then(["round"]).printed_line, "0 0")
+  end
+end
+
+class AddTest < Test::Unit::TestCase
+  include Ankit
+  include Ankit::TestHelper
+
+  THE_TEXT = "O:There is no Frigate like a Book\n"
+  THE_NAME = "there-is-no-frigate-like-a-book.card"
+
+  def assert_written(runtime, paths)
+    assert_equal(paths.size, runtime.printed_lines.size)
+    runtime.printed_lines.zip(paths).each do |line, path|
+      assert_equal(path, line)
+      assert(File.file?(path))
+    end
+  end
+  
+  def test_hello_stdin
+    with_runtime_on_temp_repo do |target|
+      target.stdin.string << THE_TEXT
+      assert_written(target.dispatch_then(["add", "--stdin"]),
+                     [File.join(target.config.card_paths[0], THE_NAME)])
+    end
+  end
+
+  def test_hello_stdin_dir
+    with_runtime_on_temp_repo do |target|
+      target.stdin.string << THE_TEXT
+      dst_dir = target.config.card_search_paths[1]
+      assert_written(target.dispatch_then(["add", "--stdin", "--dir", dst_dir]),
+                     [File.join(dst_dir, THE_NAME)])
+    end
+  end
+
+  def test_hello_two_file
+    with_runtime_on_temp_repo do |target|
+      dst_dir = target.config.card_search_paths[1]
+      assert_written(target.dispatch_then(["add", test_data_at("hope.card"), test_data_at("luck.card")]),
+                     [File.join(target.config.card_paths[0], "hope-is-the-thing-with-feathers.card"),
+                      File.join(target.config.card_paths[0], "luck-is-not-chance.card")])
+    end
+  end
+end
+
+class ComingTest < Test::Unit::TestCase
+  include Ankit
+  include Ankit::TestHelper
+  include Ankit::CardNaming
+
+  def test_name
+    with_runtime_on_temp_repo do |target|
+      assert_equal(target.dispatch_then(["coming", "--name"]).printed_lines,
+                   ["vanilla-please", "bye", "how-are-you", "hello"])
+    end
+  end
+
+  def test_limit
+    with_runtime_on_temp_repo do |target|
+      
+      assert_equal(target.dispatch_then(["coming", "--name", "1"]).printed_lines,
+                   ["vanilla-please"])
+    end
+  end
+
+  def test_hello
+    with_runtime_on_temp_repo do |target|
+      dir = File.join(target.config.repo, "cards/foo")
+      assert_equal(target.dispatch_then(["coming"]).printed_lines, 
+                   [to_card_path(dir, "vanilla-please"),
+                    to_card_path(dir, "hello")])
+    end
+  end
+end
+
+class FailPassTest < Test::Unit::TestCase
+  include Ankit
+  include Ankit::TestHelper
+  include Ankit::CardNaming, Ankit::Coming
+
+  VANILLA = "vanilla-please"
+  JUNIOR  = "bye"
+  MIDDLE  = "how-are-you"
+  VINTAGE = "hello"
+
+  def path_for(runtime, name)
+    dir = File.join(runtime.config.repo, "cards/foo")
+    to_card_path(dir, name)
+  end
+
+  def run_test_against(command, card, &block)
+    with_runtime_on_temp_repo do |target|
+      path = path_for(target, card)
+      target.dispatch([command, path])
+      assert_equal(target.printed_lines.size, 1)
+      events = Coming.coming_events(target)
+      block.call(events)
+    end
+  end
+
+  def test_pass_vanilla
+    run_test_against("pass", VANILLA) do |events|
+      assert_equal(events[0].name, VANILLA)
+      assert_equal(events[0].maturity, 1)
+    end
+  end
+
+  def test_pass_vintage
+    run_test_against("pass", VINTAGE) do |events|
+      assert_equal(events.map(&:name), [VANILLA, JUNIOR, MIDDLE, VINTAGE])
+    end
+  end
+
+  def test_pass_junior
+    run_test_against("pass", JUNIOR) do |events|
+      assert_equal(events.map(&:name), [VANILLA, MIDDLE, JUNIOR, VINTAGE])
+      assert_equal(events[2].maturity, 3)
+    end
+  end
+
+  def test_fail_vanilla
+    run_test_against("fail", VANILLA) do |events|
+      assert_equal(events[0].name, VANILLA)
+      assert_equal(events[0].maturity, 0)
+    end
+  end
+
+  def test_fail_vintage
+    run_test_against("fail", VINTAGE) do |events|
+      assert_equal(events.map(&:name), [VANILLA, VINTAGE, JUNIOR, MIDDLE])
+      assert_equal(events[0].maturity, 0)
+    end
+  end
+end
+
+class ChallengeTest < Test::Unit::TestCase
+  include Ankit
+  include Ankit::TestHelper
+  include Ankit::CardNaming, Ankit::Coming
+
+  def test_initial_state
+    with_runtime_on_temp_repo do |target|
+      actual = ChallengeCommand.new(target).initial_state
+      assert_instance_of(Challenge::QuestionState, actual)
+      assert_equal(2, actual.progress.slots.size)
+    end
+  end
+
+  def test_initial_state_limit_default
+    runtime = make_runtime(NUMBER_REPO)
+    actual = runtime.make_command(["challenge"]).initial_state
+    assert_equal(actual.progress.size, ChallengeCommand::DEFAULT_COUNT)
+  end
+
+  def test_initial_state_limit_args
+    runtime = make_runtime(NUMBER_REPO)
+    actual = runtime.make_command(["challenge", "--limit", "2"]).initial_state
+    assert_equal(actual.progress.size, 2)
+  end
+
+  FIRST_CORRECT_ANSWER = "Vanilla, Please?"
+  SECOND_CORRECT_ANSWER = "Hello"
+  FIRST_WRONG_ANSWER = "Doesn't Match"
+  FIRST_TYPO_ANSWER = "Vanilla, Please!"  
+
+  def hit_return_pump(state)
+    state.progress.runtime.line = HighLine.new
+    state.progress.runtime.line.stubs(:say).at_least(0)
+    state.progress.runtime.line.stubs(:ask).once()
+    state.pump
+  end
+
+  def enter_text_pump(state, text)
+    state.progress.runtime.line = HighLine.new
+    state.progress.runtime.line.stubs(:say).at_least(1)
+    state.progress.runtime.line.stubs(:ask).once().returns(text)
+    state.pump
+  end
+
+  def agree_pump(state, that)
+    state.progress.runtime.line = HighLine.new
+    state.progress.runtime.line.stubs(:say).at_least(0)
+    state.progress.runtime.line.stubs(:ask).once().returns(that)
+    state.pump
+  end
+
+  def test_question_to_fail
+    with_runtime_on_temp_repo do |runtime|
+      actual = ChallengeCommand.new(runtime).initial_state
+      actual_next = enter_text_pump(actual, FIRST_WRONG_ANSWER)
+      assert_instance_of(Challenge::FailedState, actual_next)
+      actual_next = hit_return_pump(actual_next)
+      assert_instance_of(Challenge::QuestionState, actual_next)
+      assert_equal(actual_next.progress.npassed, 0)
+      assert_equal(actual_next.progress.nfailed, 1)
+    end
+  end
+
+  def test_question_to_typo
+    with_runtime_on_temp_repo do |runtime|
+      actual = ChallengeCommand.new(runtime).initial_state
+      actual_next = enter_text_pump(actual, FIRST_TYPO_ANSWER)
+      assert_instance_of(Challenge::TypoState, actual_next)
+      actual_next = hit_return_pump(actual_next)
+      assert_instance_of(Challenge::QuestionState, actual_next)
+      assert_equal(actual_next.progress.npassed, 0)
+      assert_equal(actual_next.progress.nfailed, 0)
+      actual_next = enter_text_pump(actual_next, FIRST_CORRECT_ANSWER)
+      assert_instance_of(Challenge::PassedState, actual_next)
+      hit_return_pump(actual_next)
+      assert_equal(actual_next.progress.npassed, 1)
+      assert_equal(actual_next.progress.nfailed, 0)
+    end
+  end
+
+  def test_question_to_pass
+    with_runtime_on_temp_repo do |runtime|
+      actual = ChallengeCommand.new(runtime).initial_state
+      actual_next = enter_text_pump(actual, FIRST_CORRECT_ANSWER)
+      assert_instance_of(Challenge::PassedState, actual_next)
+      actual_next = hit_return_pump(actual_next)
+      assert_instance_of(Challenge::QuestionState, actual_next)
+      assert_equal(actual_next.progress.npassed, 1)
+      assert_equal(actual_next.progress.nfailed, 0)
+    end
+  end
+
+  def pass_two(state)
+    state = enter_text_pump(state, FIRST_CORRECT_ANSWER)
+    assert_instance_of(Challenge::PassedState, state)
+    state = hit_return_pump(state)
+    assert_instance_of(Challenge::QuestionState, state)
+    state = enter_text_pump(state, SECOND_CORRECT_ANSWER)
+    assert_instance_of(Challenge::PassedState, state)
+    hit_return_pump(state)
+  end
+
+  def test_to_breaking
+    with_runtime_on_temp_repo do |runtime|
+      actual = ChallengeCommand.new(runtime).initial_state
+      actual_next = pass_two(actual)
+      assert_instance_of(Challenge::BreakingState, actual_next)
+    end
+  end
+
+  def test_to_breaking_to_over
+    with_runtime_on_temp_repo do |runtime|
+      actual = ChallengeCommand.new(runtime).initial_state
+      actual = pass_two(actual)
+      actual = agree_pump(actual, "n")
+      assert_instance_of(Challenge::OverState, actual)
+    end
+  end
+
+  def test_to_breaking_to_more
+    with_runtime_on_temp_repo do |runtime|
+      actual = ChallengeCommand.new(runtime).initial_state
+      actual = pass_two(actual)
+      actual = agree_pump(actual, "y")
+      assert_instance_of(Challenge::QuestionState, actual)
+    end
+  end
+
+  def test_to_breaking_to_more
+    with_runtime_on_temp_repo do |runtime|
+      actual = ChallengeCommand.new(runtime).initial_state
+      actual = pass_two(actual)
+      actual = agree_pump(actual, "?")
+      assert_instance_of(Challenge::BreakingState, actual)
+    end
+  end
+end
+
+class StylableTextTest < Test::Unit::TestCase
+  include Ankit
+  include Ankit::TestHelper
+
+  def test_hello
+    assert_equal("Hello, *****!", 
+                 Card.new(o: "Hello, [World]!").hidden_original)
+    assert_equal("*****, *****!", 
+                 Card.new(o: "Hello, World!").hidden_original)
+  end
+
+  def test_diff
+    StylableText.new("hello").diff("helo")
+    StylableText.new("helo").diff("hello")
+    StylableText.new("helxo").diff("hello")
+  end
+end

data/test/data/bye_card.card

@@ -0,0 +1,2 @@
+O:Bye, Universe!
+T:Sayonara Uchu!!

data/test/data/hello_card.card

@@ -0,0 +1,2 @@
+O:Hello, World!
+T:Konichiwa Sekai!!

data/test/data/hello_config.rb

@@ -0,0 +1,4 @@
+
+self.repo = "hello_repo"
+self.location = "hello"
+self.card_paths << "#{repo}/more"

data/test/data/hello_repo/anemone.journal

@@ -0,0 +1,2 @@
+{"envelope":{"at":"2001-02-03T04:05:06+00:00","round":5}, "values":{"type":"card","verb":"add","name":"hello","maturity":1}}
+{"envelope":{"at":"2001-02-03T04:05:06+00:00","round":5}, "values":{"type":"card","verb":"add","name":"bye","maturity":2}}

data/test/data/hello_repo/baobab.journal

@@ -0,0 +1,2 @@
+{"envelope":{"at":"2001-02-03T04:05:06+00:00","round":6}, "values":{"type":"card","verb":"add","name":"hello","maturity":4}}
+{"envelope":{"at":"2001-02-03T04:05:06+00:00","round":5}, "values":{"type":"card","verb":"add","name":"how-are-you","maturity":3}}

data/test/data/hello_repo/cards/foo/hello.card

@@ -0,0 +1,2 @@
+O: Hello
+T: Konnichiwa

data/test/data/hello_repo/cards/foo/this_is_not_a_card.txt

@@ -0,0 +1 @@
+This isn't a card.

data/test/data/hello_repo/cards/foo/vanilla-please.card

@@ -0,0 +1,2 @@
+O: [Vanilla], Please?
+T: Konnichiwa

data/test/data/hope.card

@@ -0,0 +1 @@
+O: Hope is the thing with feathers

data/test/data/luck.card

@@ -0,0 +1 @@
+O: Luck is not chance

data/test/data/number_repo/cards/eight.card

@@ -0,0 +1,2 @@
+O: Eight
+T: Hachi

data/test/data/number_repo/cards/five.card

@@ -0,0 +1,2 @@
+O: Five
+T: Go

data/test/data/number_repo/cards/four.card

@@ -0,0 +1,2 @@
+O: Four
+T: Shi

data/test/data/number_repo/cards/one.card

@@ -0,0 +1,2 @@
+O: One
+T: Ichi

data/test/data/number_repo/cards/seven.card

@@ -0,0 +1,2 @@
+O: Seven
+T: Nana

data/test/data/number_repo/cards/six.card

@@ -0,0 +1,2 @@
+O: Six
+T: Roku

data/test/data/number_repo/cards/three.card

@@ -0,0 +1,2 @@
+O: Three
+T: San

data/test/data/number_repo/cards/two.card

@@ -0,0 +1,2 @@
+O: Two
+T: Ni

data/test/event_test.rb

@@ -0,0 +1,29 @@
+
+require 'ankit/event'
+require 'test/unit'
+
+class EventTest < Test::Unit::TestCase
+  include Ankit
+
+  def setup
+    @target = Event.parse('{"envelope":{"at":"2001-02-03T04:05:06+00:00","round":1},' +
+                          '"values":{"type":"card","verb":"add","name":"hello","maturity":1}}')
+    @next_envelope = Envelope.parse('{"at":"2002-03-04T05:06:07+00:00","round":2}')
+  end
+
+  def test_to_passed
+    expected = Event.new(@next_envelope, JSON.parse('{"type":"card","verb":"passed","name":"hello","maturity":2}'))
+    actual = @target.to_passed(@next_envelope)
+    assert_equal(actual, expected)
+  end
+
+  def test_to_failed
+    expected = Event.new(@next_envelope, JSON.parse('{"type":"card","verb":"failed","name":"hello","maturity":0}'))
+    actual = @target.to_failed(@next_envelope)
+    assert_equal(actual, expected)
+  end
+
+  def test_next_round
+    assert_equal(@target.next_round, 3)
+  end
+end

data/test/helpers.rb

@@ -0,0 +1,54 @@
+
+require 'ankit/runtime'
+require 'stringio'
+require 'fileutils'
+
+module Ankit
+  TEST_DATA_BASE = File.join(File.dirname(__FILE__), "data")
+  HELLO_REPO = File.join(TEST_DATA_BASE, "hello_repo")
+  VANILLA_REPO = File.join(TEST_DATA_BASE, "vanilla_repo")
+  NUMBER_REPO = File.join(TEST_DATA_BASE, "number_repo")
+
+  class RuntimeWithMockedIO < Runtime
+    def initialize(config)
+      super
+      supress_io
+    end
+
+    def printed_line; self.stdout.string.strip; end
+    def printed_lines; self.stdout.string.split("\n").map(&:strip); end
+
+    def self.prepare_default; end
+  end
+
+  module TestHelper
+    def test_data_at(*args) File.join(TEST_DATA_BASE, *args); end
+    def repo_data_at(*args) File.join(HELLO_REPO, *args); end
+
+    def copy_hello_repo_to(dst)
+      FileUtils.cp_r(HELLO_REPO, dst)
+      File.join(dst, File.basename(HELLO_REPO))
+    end
+
+    def make_config(repo_dir=HELLO_REPO)
+      config = Config.new
+      config.repo = repo_dir
+      config.location = "anomone"
+      config
+    end
+
+    def make_runtime(repo_dir=HELLO_REPO)
+      RuntimeWithMockedIO.new(make_config(repo_dir))
+    end
+
+    def make_vanilla_runtime()
+      make_runtime(VANILLA_REPO)
+    end
+
+    def with_runtime_on_temp_repo(&block)
+      Dir.mktmpdir do |temp_repo|
+        block.call(make_runtime(copy_hello_repo_to(temp_repo)))
+      end
+    end
+  end
+end

data/test/progress_test.rb

@@ -0,0 +1,99 @@
+
+require 'ankit/runtime'
+require 'test/unit'
+
+class ProgressTest < Test::Unit::TestCase
+  include Ankit
+  include Ankit::TestHelper
+  include Ankit::CardNaming
+  include Challenge
+
+  def make_target(runtime)
+    Progress.new(Session.new(runtime), [Slot.new("path1"), Slot.new("path2"), Slot.new("path3")])
+  end
+
+  def first_slot_event_of(progress)
+    EventTraversing.find_latest_event_for(progress.runtime, progress.slots[0].path)
+  end
+
+  def test_fail
+    with_runtime_on_temp_repo do |runtime|
+      target = make_target(runtime)
+      target.fail
+      fetched_event = first_slot_event_of(target)
+      assert_equal(target.index, 0)
+      assert_equal(target.slots[0].rating, :failed)
+      assert_equal(target.slots[0].event, fetched_event)
+      assert_equal(0, fetched_event.maturity)
+      assert(runtime.printed_line.empty?)
+      assert_equal(1, target.nfailed)
+      assert_equal(0, target.npassed)
+    end
+  end
+
+  def test_pass
+    with_runtime_on_temp_repo do |runtime|
+      target = make_target(runtime)
+      target.pass
+      fetched_event = first_slot_event_of(target)
+      assert_equal(target.index, 1)
+      assert_equal(target.slots[0].rating, :passed)
+      assert_equal(target.slots[0].event, fetched_event)
+      assert_equal(1, fetched_event.maturity)
+      assert(runtime.printed_line.empty?)
+
+      assert_equal(0, target.nfailed)
+      assert_equal(1, target.npassed)
+    end
+  end
+
+  def test_fail_then_pass
+    with_runtime_on_temp_repo do |runtime|
+      target = make_target(runtime)
+      target.fail
+      target.pass
+      fetched_event = first_slot_event_of(target)
+      assert_equal(target.index, 1)
+      assert_equal(target.slots[0].rating, :failed)
+      assert_equal(target.slots[0].event, fetched_event)
+      assert_equal(0, fetched_event.maturity)
+
+      assert_equal(1, target.nfailed)
+      assert_equal(0, target.npassed)
+    end
+  end
+
+  def test_round_during_progress
+    with_runtime_on_temp_repo do |runtime|
+      target = make_target(runtime)
+      target.pass
+      e1 = EventTraversing.find_latest_event_named(runtime, "path1")
+      target.pass
+      e2 = EventTraversing.find_latest_event_named(runtime, "path2")
+      assert_equal(target.this_round, e1.round)
+      assert_equal(target.this_round, e2.round)
+    end
+  end
+
+  def test_indicator
+    with_runtime_on_temp_repo do |runtime|
+      target = make_target(runtime)
+      assert_equal("---", target.indicator)
+      target.pass
+      assert_equal("o--", target.indicator)
+      target.attack
+      assert_equal("o*-", target.indicator)
+      target.fail
+      assert_equal("ox-", target.indicator)
+    end
+  end
+
+  def test_round_delta
+    with_runtime_on_temp_repo do |runtime|
+      target = make_target(runtime).pass.pass.pass
+      assert_equal(1, target.round_delta)
+    end
+  end
+
+end
+