From: Lucas Kanashiro Date: Fri, 16 Sep 2022 12:25:51 -0300 Subject: Skip tests which require types included in mustermann-contrib mustermann-contrib is not shipped, it requires new dependencies. Due to that the following types does not work: - rails - shell - simple - template Forwarded: not-needed --- mustermann/spec/composite_spec.rb | 6 +++--- mustermann/spec/concat_spec.rb | 12 ++++++------ mustermann/spec/expander_spec.rb | 20 ++++++++++---------- mustermann/spec/mapper_spec.rb | 2 +- mustermann/spec/mustermann_spec.rb | 22 +++++++++++----------- mustermann/spec/pattern_spec.rb | 6 +++--- mustermann/spec/to_pattern_spec.rb | 18 +++++++++--------- 7 files changed, 43 insertions(+), 43 deletions(-) --- a/mustermann/spec/composite_spec.rb +++ b/mustermann/spec/composite_spec.rb @@ -56,7 +56,7 @@ describe Mustermann::Composite do example { subject.expand(name: 'bar') .should be == '/foo/bar' } example { subject.expand(first: 'fox', second: 'bar') .should be == '/fox/bar' } - context "without expandable patterns" do + xcontext "without expandable patterns" do subject(:pattern) { Mustermann.new('/foo/:name', '/:first/:second', type: :simple) } example { subject.should_not respond_to(:expand) } example { expect { subject.expand(name: 'bar') }.to raise_error(NotImplementedError) } @@ -67,7 +67,7 @@ describe Mustermann::Composite do example { should respond_to(:to_templates) } example { should generate_templates('/foo/{name}', '/{first}/{second}') } - context "without patterns implementing to_templates" do + xcontext "without patterns implementing to_templates" do subject(:pattern) { Mustermann.new('/foo/:name', '/:first/:second', type: :simple) } example { should_not respond_to(:to_templates) } example { expect { subject.to_templates }.to raise_error(NotImplementedError) } @@ -150,7 +150,7 @@ describe Mustermann::Composite do end end - describe :inspect do + xdescribe :inspect do let(:sinatra) { Mustermann.new('x') } let(:shell) { Mustermann.new('x', type: :shell) } let(:identity) { Mustermann.new('x', type: :identity) } --- a/mustermann/spec/concat_spec.rb +++ b/mustermann/spec/concat_spec.rb @@ -22,19 +22,19 @@ describe Mustermann::Concat do its(:to_s) { should be == "foobar" } end - context "sinatra + rails" do + xcontext "sinatra + rails" do subject(:pattern) { Mustermann.new("/:foo") + Mustermann.new("/:bar", type: :rails) } its(:class) { should be == Mustermann::Sinatra } its(:to_s) { should be == "/{foo}/{bar}" } end - context "sinatra + flask" do + xcontext "sinatra + flask" do subject(:pattern) { Mustermann.new("/:foo") + Mustermann.new("/", type: :flask) } its(:class) { should be == Mustermann::Sinatra } its(:to_s) { should be == "/{foo}/{bar}" } end - context "sinatra + flask (typed)" do + xcontext "sinatra + flask (typed)" do subject(:pattern) { Mustermann.new("/:foo") + Mustermann.new("/", type: :flask) } its(:class) { should be == Mustermann::Concat } its(:to_s) { should be == '(sinatra:"/:foo" + flask:"/")' } @@ -46,13 +46,13 @@ describe Mustermann::Concat do its(:to_s) { should be == '(sinatra:"/:foo" + sinatra:"/:bar")' } end - context "sinatra + rails (different options)" do + xcontext "sinatra + rails (different options)" do subject(:pattern) { Mustermann.new("/:foo") + Mustermann.new("/:bar", type: :rails, uri_decode: false) } its(:class) { should be == Mustermann::Concat } its(:to_s) { should be == '(sinatra:"/:foo" + rails:"/:bar")' } end - context "sinatra + rails (different options) + sinatra" do + xcontext "sinatra + rails (different options) + sinatra" do subject(:pattern) { Mustermann.new("/:foo") + Mustermann.new("/:bar", type: :rails, uri_decode: false) + Mustermann.new("/:baz") } its(:class) { should be == Mustermann::Concat } its(:to_s) { should be == '(sinatra:"/:foo" + rails:"/:bar" + sinatra:"/:baz")' } @@ -64,7 +64,7 @@ describe Mustermann::Concat do its(:to_s) { should be == '(sinatra:"/foo/bar" + regular:"baz")' } end - context "sinatra + (sinatra + rails (different options) + sinatra)" do + xcontext "sinatra + (sinatra + rails (different options) + sinatra)" do subject(:pattern) { Mustermann.new("/foo") + (Mustermann.new("/bar") + Mustermann.new("/baz", type: :rails, uri_decode: false) + Mustermann.new("/boo")) } its(:class) { should be == Mustermann::Concat } its(:to_s) { should be == '(sinatra:"/foo/bar" + rails:"/baz" + sinatra:"/boo")' } --- a/mustermann/spec/expander_spec.rb +++ b/mustermann/spec/expander_spec.rb @@ -14,13 +14,13 @@ describe Mustermann::Expander do expander.expand(foo: 23).should be == "/23" end - it 'supports setting pattern options' do + xit 'supports setting pattern options' do expander = Mustermann::Expander.new(type: :rails) << "/:foo(.:ext)" << "/:bar" expander.expand(foo: 42, ext: 'jpg').should be == "/42.jpg" expander.expand(foo: 42).should be == "/42" end - it 'supports combining different pattern styles' do + xit 'supports combining different pattern styles' do expander = Mustermann::Expander.new << Mustermann.new("/:foo(.:ext)", type: :rails) << Mustermann.new("/:bar", type: :sinatra) expander.expand(foo: 'pony', ext: 'jpg').should be == '/pony.jpg' expander.expand(bar: 23).should be == "/23" @@ -96,28 +96,28 @@ describe Mustermann::Expander do describe :== do example { Mustermann::Expander.new('/foo') .should be == Mustermann::Expander.new('/foo') } example { Mustermann::Expander.new('/foo') .should_not be == Mustermann::Expander.new('/bar') } - example { Mustermann::Expander.new('/foo', type: :rails) .should be == Mustermann::Expander.new('/foo', type: :rails) } - example { Mustermann::Expander.new('/foo', type: :rails) .should_not be == Mustermann::Expander.new('/foo', type: :sinatra) } + xexample { Mustermann::Expander.new('/foo', type: :rails) .should be == Mustermann::Expander.new('/foo', type: :rails) } + xexample { Mustermann::Expander.new('/foo', type: :rails) .should_not be == Mustermann::Expander.new('/foo', type: :sinatra) } end describe :hash do example { Mustermann::Expander.new('/foo') .hash.should be == Mustermann::Expander.new('/foo').hash } example { Mustermann::Expander.new('/foo') .hash.should_not be == Mustermann::Expander.new('/bar').hash } - example { Mustermann::Expander.new('/foo', type: :rails) .hash.should be == Mustermann::Expander.new('/foo', type: :rails).hash } - example { Mustermann::Expander.new('/foo', type: :rails) .hash.should_not be == Mustermann::Expander.new('/foo', type: :sinatra).hash } + xexample { Mustermann::Expander.new('/foo', type: :rails) .hash.should be == Mustermann::Expander.new('/foo', type: :rails).hash } + xexample { Mustermann::Expander.new('/foo', type: :rails) .hash.should_not be == Mustermann::Expander.new('/foo', type: :sinatra).hash } end describe :eql? do example { Mustermann::Expander.new('/foo') .should be_eql Mustermann::Expander.new('/foo') } example { Mustermann::Expander.new('/foo') .should_not be_eql Mustermann::Expander.new('/bar') } - example { Mustermann::Expander.new('/foo', type: :rails) .should be_eql Mustermann::Expander.new('/foo', type: :rails) } - example { Mustermann::Expander.new('/foo', type: :rails) .should_not be_eql Mustermann::Expander.new('/foo', type: :sinatra) } + xexample { Mustermann::Expander.new('/foo', type: :rails) .should be_eql Mustermann::Expander.new('/foo', type: :rails) } + xexample { Mustermann::Expander.new('/foo', type: :rails) .should_not be_eql Mustermann::Expander.new('/foo', type: :sinatra) } end describe :equal? do example { Mustermann::Expander.new('/foo') .should_not be_equal Mustermann::Expander.new('/foo') } example { Mustermann::Expander.new('/foo') .should_not be_equal Mustermann::Expander.new('/bar') } - example { Mustermann::Expander.new('/foo', type: :rails) .should_not be_equal Mustermann::Expander.new('/foo', type: :rails) } - example { Mustermann::Expander.new('/foo', type: :rails) .should_not be_equal Mustermann::Expander.new('/foo', type: :sinatra) } + xexample { Mustermann::Expander.new('/foo', type: :rails) .should_not be_equal Mustermann::Expander.new('/foo', type: :rails) } + xexample { Mustermann::Expander.new('/foo', type: :rails) .should_not be_equal Mustermann::Expander.new('/foo', type: :sinatra) } end end --- a/mustermann/spec/mapper_spec.rb +++ b/mustermann/spec/mapper_spec.rb @@ -25,7 +25,7 @@ describe Mustermann::Mapper do example { mapper['/fox'].should be == '/fox' } end - context 'allows specifying type' do + xcontext 'allows specifying type' do subject(:mapper) { Mustermann::Mapper.new({ "/foo" => "/bar" }, additional_values: :raise, type: :rails) } its(:to_h) { should be == { Mustermann.new("/foo", type: :rails) => Mustermann::Expander.new("/bar", type: :rails) } } example { mapper['/foo'].should be == '/bar' } --- a/mustermann/spec/mustermann_spec.rb +++ b/mustermann/spec/mustermann_spec.rb @@ -8,11 +8,11 @@ describe Mustermann do context "string argument" do example { Mustermann.new('') .should be_a(Mustermann::Sinatra) } example { Mustermann.new('', type: :identity) .should be_a(Mustermann::Identity) } - example { Mustermann.new('', type: :rails) .should be_a(Mustermann::Rails) } - example { Mustermann.new('', type: :shell) .should be_a(Mustermann::Shell) } + xexample { Mustermann.new('', type: :rails) .should be_a(Mustermann::Rails) } + xexample { Mustermann.new('', type: :shell) .should be_a(Mustermann::Shell) } example { Mustermann.new('', type: :sinatra) .should be_a(Mustermann::Sinatra) } - example { Mustermann.new('', type: :simple) .should be_a(Mustermann::Simple) } - example { Mustermann.new('', type: :template) .should be_a(Mustermann::Template) } + xexample { Mustermann.new('', type: :simple) .should be_a(Mustermann::Simple) } + xexample { Mustermann.new('', type: :template) .should be_a(Mustermann::Template) } example { expect { Mustermann.new('', foo: :bar) }.to raise_error(ArgumentError, "unsupported option :foo for Mustermann::Sinatra") } example { expect { Mustermann.new('', type: :ast) }.to raise_error(ArgumentError, "unsupported type :ast (cannot load such file -- mustermann/ast)") } @@ -21,18 +21,18 @@ describe Mustermann do context "pattern argument" do subject(:pattern) { Mustermann.new('') } example { Mustermann.new(pattern).should be == pattern } - example { Mustermann.new(pattern, type: :rails).should be_a(Mustermann::Sinatra) } + xexample { Mustermann.new(pattern, type: :rails).should be_a(Mustermann::Sinatra) } end context "regexp argument" do example { Mustermann.new(//) .should be_a(Mustermann::Regular) } - example { Mustermann.new(//, type: :rails) .should be_a(Mustermann::Regular) } + xexample { Mustermann.new(//, type: :rails) .should be_a(Mustermann::Regular) } end context "argument implementing #to_pattern" do subject(:pattern) { Class.new { def to_pattern(**o) Mustermann.new('foo', **o) end }.new } example { Mustermann.new(pattern) .should be_a(Mustermann::Sinatra) } - example { Mustermann.new(pattern, type: :rails) .should be_a(Mustermann::Rails) } + xexample { Mustermann.new(pattern, type: :rails) .should be_a(Mustermann::Rails) } example { Mustermann.new(pattern).to_s.should be == 'foo' } end @@ -56,11 +56,11 @@ describe Mustermann do describe :[] do example { Mustermann[:identity] .should be == Mustermann::Identity } - example { Mustermann[:rails] .should be == Mustermann::Rails } - example { Mustermann[:shell] .should be == Mustermann::Shell } + xexample { Mustermann[:rails] .should be == Mustermann::Rails } + xexample { Mustermann[:shell] .should be == Mustermann::Shell } example { Mustermann[:sinatra] .should be == Mustermann::Sinatra } - example { Mustermann[:simple] .should be == Mustermann::Simple } - example { Mustermann[:template] .should be == Mustermann::Template } + xexample { Mustermann[:simple] .should be == Mustermann::Simple } + xexample { Mustermann[:template] .should be == Mustermann::Template } example { expect { Mustermann[:ast] }.to raise_error(ArgumentError, "unsupported type :ast (cannot load such file -- mustermann/ast)") } example { expect { Mustermann[:expander] }.to raise_error(ArgumentError, "unsupported type :expander") } --- a/mustermann/spec/pattern_spec.rb +++ b/mustermann/spec/pattern_spec.rb @@ -34,20 +34,20 @@ describe Mustermann::Pattern do example { Mustermann::Pattern.new('/foo') .should be == Mustermann::Pattern.new('/foo') } example { Mustermann::Pattern.new('/foo') .should_not be == Mustermann::Pattern.new('/bar') } example { Mustermann::Sinatra.new('/foo') .should be == Mustermann::Sinatra.new('/foo') } - example { Mustermann::Rails.new('/foo') .should_not be == Mustermann::Sinatra.new('/foo') } + xexample { Mustermann::Rails.new('/foo') .should_not be == Mustermann::Sinatra.new('/foo') } end describe :eql? do example { Mustermann::Pattern.new('/foo') .should be_eql Mustermann::Pattern.new('/foo') } example { Mustermann::Pattern.new('/foo') .should_not be_eql Mustermann::Pattern.new('/bar') } example { Mustermann::Sinatra.new('/foo') .should be_eql Mustermann::Sinatra.new('/foo') } - example { Mustermann::Rails.new('/foo') .should_not be_eql Mustermann::Sinatra.new('/foo') } + xexample { Mustermann::Rails.new('/foo') .should_not be_eql Mustermann::Sinatra.new('/foo') } end describe :equal? do example { Mustermann::Pattern.new('/foo') .should be_equal Mustermann::Pattern.new('/foo') } example { Mustermann::Pattern.new('/foo') .should_not be_equal Mustermann::Pattern.new('/bar') } example { Mustermann::Sinatra.new('/foo') .should be_equal Mustermann::Sinatra.new('/foo') } - example { Mustermann::Rails.new('/foo') .should_not be_equal Mustermann::Sinatra.new('/foo') } + xexample { Mustermann::Rails.new('/foo') .should_not be_equal Mustermann::Sinatra.new('/foo') } end end --- a/mustermann/spec/to_pattern_spec.rb +++ b/mustermann/spec/to_pattern_spec.rb @@ -6,28 +6,28 @@ require 'delegate' describe Mustermann::ToPattern do context String do example { "".to_pattern .should be_a(Mustermann::Sinatra) } - example { "".to_pattern(type: :rails) .should be_a(Mustermann::Rails) } + xexample { "".to_pattern(type: :rails) .should be_a(Mustermann::Rails) } end context Regexp do example { //.to_pattern .should be_a(Mustermann::Regular) } - example { //.to_pattern(type: :rails) .should be_a(Mustermann::Regular) } + xexample { //.to_pattern(type: :rails) .should be_a(Mustermann::Regular) } end context Symbol do example { :foo.to_pattern .should be_a(Mustermann::Sinatra) } - example { :foo.to_pattern(type: :rails) .should be_a(Mustermann::Sinatra) } + xexample { :foo.to_pattern(type: :rails) .should be_a(Mustermann::Sinatra) } end context Array do example { [:foo, :bar].to_pattern .should be_a(Mustermann::Composite) } - example { [:foo, :bar].to_pattern(type: :rails) .should be_a(Mustermann::Composite) } + xexample { [:foo, :bar].to_pattern(type: :rails) .should be_a(Mustermann::Composite) } end context Mustermann::Pattern do subject(:pattern) { Mustermann.new('') } example { pattern.to_pattern.should be == pattern } - example { pattern.to_pattern(type: :rails).should be_a(Mustermann::Sinatra) } + xexample { pattern.to_pattern(type: :rails).should be_a(Mustermann::Sinatra) } end context 'custom class' do @@ -41,9 +41,9 @@ describe Mustermann::ToPattern do end example { example_class.new.to_pattern .should be_a(Mustermann::Sinatra) } - example { example_class.new.to_pattern(type: :rails) .should be_a(Mustermann::Rails) } + xexample { example_class.new.to_pattern(type: :rails) .should be_a(Mustermann::Rails) } example { Mustermann.new(example_class.new) .should be_a(Mustermann::Sinatra) } - example { Mustermann.new(example_class.new, type: :rails) .should be_a(Mustermann::Rails) } + xexample { Mustermann.new(example_class.new, type: :rails) .should be_a(Mustermann::Rails) } end context 'primitive delegate' do @@ -54,7 +54,7 @@ describe Mustermann::ToPattern do end example { example_class.new([:foo, :bar]).to_pattern .should be_a(Mustermann::Composite) } - example { example_class.new([:foo, :bar]).to_pattern(type: :rails) .should be_a(Mustermann::Composite) } + xexample { example_class.new([:foo, :bar]).to_pattern(type: :rails) .should be_a(Mustermann::Composite) } end context 'primitive subclass' do @@ -65,6 +65,6 @@ describe Mustermann::ToPattern do end example { example_class.new([:foo, :bar]).to_pattern .should be_a(Mustermann::Composite) } - example { example_class.new([:foo, :bar]).to_pattern(type: :rails) .should be_a(Mustermann::Composite) } + xexample { example_class.new([:foo, :bar]).to_pattern(type: :rails) .should be_a(Mustermann::Composite) } end end