File: command_spec.rb

package info (click to toggle)
ruby-thor 0.19.1-3
  • links: PTS, VCS
  • area: main
  • in suites: stretch
  • size: 792 kB
  • ctags: 567
  • sloc: ruby: 7,315; makefile: 2; sh: 1
file content (79 lines) | stat: -rw-r--r-- 2,755 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
require "helper"

describe Thor::Command do
  def command(options = {})
    options.each do |key, value|
      options[key] = Thor::Option.parse(key, value)
    end

    @command ||= Thor::Command.new(:can_has, "I can has cheezburger", "I can has cheezburger\nLots and lots of it", "can_has", options)
  end

  describe "#formatted_usage" do
    it "includes namespace within usage" do
      object = Struct.new(:namespace, :arguments).new("foo", [])
      expect(command(:bar => :required).formatted_usage(object)).to eq("foo:can_has --bar=BAR")
    end

    it "includes subcommand name within subcommand usage" do
      object = Struct.new(:namespace, :arguments).new("main:foo", [])
      expect(command(:bar => :required).formatted_usage(object, false, true)).to eq("foo can_has --bar=BAR")
    end

    it "removes default from namespace" do
      object = Struct.new(:namespace, :arguments).new("default:foo", [])
      expect(command(:bar => :required).formatted_usage(object)).to eq(":foo:can_has --bar=BAR")
    end

    it "injects arguments into usage" do
      options = {:required => true, :type => :string}
      object = Struct.new(:namespace, :arguments).new("foo", [Thor::Argument.new(:bar, options)])
      expect(command(:foo => :required).formatted_usage(object)).to eq("foo:can_has BAR --foo=FOO")
    end
  end

  describe "#dynamic" do
    it "creates a dynamic command with the given name" do
      expect(Thor::DynamicCommand.new("command").name).to eq("command")
      expect(Thor::DynamicCommand.new("command").description).to eq("A dynamically-generated command")
      expect(Thor::DynamicCommand.new("command").usage).to eq("command")
      expect(Thor::DynamicCommand.new("command").options).to eq({})
    end

    it "does not invoke an existing method" do
      dub = double
      expect(dub.class).to receive(:handle_no_command_error).with("to_s")
      Thor::DynamicCommand.new("to_s").run(dub)
    end
  end

  describe "#dup" do
    it "dup options hash" do
      command = Thor::Command.new("can_has", nil, nil, nil, :foo => true, :bar => :required)
      command.dup.options.delete(:foo)
      expect(command.options[:foo]).to be
    end
  end

  describe "#run" do
    xit "runs a command by calling a method in the given instance" do
      dub = double
      expect(dub).to receive(:can_has).and_return { |*args| args }
      expect(command.run(dub, [1, 2, 3])).to eq([1, 2, 3])
    end

    it "raises an error if the method to be invoked is private" do
      klass = Class.new do
        def self.handle_no_command_error(name)
          name
        end
        def can_has
          "fail"
        end
        private :can_has
      end

      expect(command.run(klass.new)).to eq("can_has")
    end
  end
end