rubirai 0.0.2

data/spec/error_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'errors' do
+  it 'should create RubiraiError with specific message' do
+    expect { raise Rubirai::RubiraiError, 'message' }
+      .to raise_error(Rubirai::RubiraiError, 'message') do |err|
+      expect(err).to be_a_kind_of(RuntimeError)
+    end
+  end
+
+  it 'should create HttpResponseError with specific message' do
+    expect { raise Rubirai::HttpResponseError, '404' }.to raise_error(
+      Rubirai::HttpResponseError,
+      'Http Error: 404'
+    ) do |err|
+      expect(err).to be_a_kind_of(Rubirai::RubiraiError)
+    end
+  end
+
+  it 'should create MiraiError with specific message' do
+    Rubirai::RETURN_CODE.each do |code, msg|
+      expect { raise Rubirai::MiraiError, code }
+        .to raise_error(Rubirai::MiraiError, "Mirai error: #{code} - #{msg}") do |err|
+        expect(err).to be_a_kind_of(Rubirai::RubiraiError)
+      end
+    end
+  end
+end

data/spec/events/event_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+describe Rubirai::Event do
+  before do
+  end
+
+  after do
+  end
+
+  it 'should parse hash to a bot online event' do
+    hash = {
+      "type": 'BotOnlineEvent',
+      "qq": 123456
+    }.stringify_keys
+    e = Rubirai::Event.parse hash
+    expect(e).to be_a(Rubirai::Event)
+    expect(e).to be_a(Rubirai::BotEvent)
+    expect(e).to be_a(Rubirai::BotOnlineEvent)
+    expect(e.qq).to eq(hash['qq'])
+  end
+
+  it 'should parse hash to a bot active offline event' do
+    hash = {
+      "type": 'BotOfflineEventActive',
+      "qq": 123456
+    }.stringify_keys
+    e = Rubirai::Event.parse hash
+    expect(e).to be_a(Rubirai::BotActiveOfflineEvent)
+    expect(e.qq).to eq(hash['qq'])
+  end
+
+  it 'should parse hash to a bot forced offline event' do
+    hash = {
+      "type": 'BotOfflineEventForce',
+      "qq": 123456
+    }.stringify_keys
+    e = Rubirai::Event.parse hash
+    expect(e).to be_a(Rubirai::BotForcedOfflineEvent)
+    expect(e.qq).to eq(hash['qq'])
+  end
+
+  it 'should parse hash to a bot dropped event' do
+    hash = {
+      "type": 'BotOfflineEventDropped',
+      "qq": 123456
+    }.stringify_keys
+    e = Rubirai::Event.parse hash
+    expect(e).to be_a(Rubirai::BotDroppedEvent)
+    expect(e.qq).to eq(hash['qq'])
+  end
+
+  it 'should parse hash to a bot relogin event' do
+    hash = {
+      "type": 'BotReloginEvent',
+      "qq": 123456
+    }.stringify_keys
+    e = Rubirai::Event.parse hash
+    expect(e).to be_a(Rubirai::BotReloginEvent)
+    expect(e.qq).to eq(hash['qq'])
+  end
+
+  it 'should parse hash to a bot permission change event' do
+    hash = {
+      "type": 'BotGroupPermissionChangeEvent',
+      "origin": 'MEMBER',
+      "new": 'ADMINISTRATOR',
+      "current": 'ADMINISTRATOR',
+      "group": {
+        "id": 123456789,
+        "name": 'Mirai Technology',
+        "permission": 'ADMINISTRATOR'
+      }
+    }
+    e = Rubirai::Event.parse hash
+    expect(e).to be_a(Rubirai::BotGroupPermissionChangedEvent)
+    expect(e.class.type)
+  end
+end

data/spec/message_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'message api' do
+  before :all do
+    @mirai_bot = new_bot
+  end
+
+  after do
+  end
+end

data/spec/messages/message_chain_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+describe Rubirai::MessageChain do
+  before do
+  end
+
+  after do
+  end
+
+  it 'converts objects to message chain' do
+    hash = {
+      "type": 'Quote',
+      "id": 123456,
+      "groupId": 123456789,
+      "senderId": 987654321,
+      "targetId": 9876543210,
+      "origin": [
+        { "type": 'Plain', text: 'text' }.stringify_keys
+      ]
+    }.stringify_keys
+    chain = Rubirai::MessageChain.make(
+      'hi', 2, Rubirai::AtMessage.from(target: 114514), 3, 'hi', :good, hash
+    )
+    arr = [
+      { type: 'Plain', text: 'hi2' },
+      { type: 'At', target: 114514 },
+      { type: 'Plain', text: '3higood' },
+      hash
+    ].map(&:stringify_keys)
+    expect(chain.to_a).to eq(arr)
+  end
+end

data/spec/messages/message_spec.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+describe Rubirai::Message do
+  before do
+  end
+
+  after do
+  end
+
+  it 'should initialize and convert Source messages correctly' do
+    hash = {
+      'type' => 'Source',
+      'id' => 123456,
+      'time' => 123456
+    }
+    sm = Rubirai::SourceMessage.new hash
+    expect(sm).to be_a(Rubirai::SourceMessage)
+    expect(sm.time).to eq(123456)
+    expect(sm.id).to eq(123456)
+    expect(sm.bot).to be_nil
+    expect(sm.type).to eq(:Source)
+
+    expect(sm.to_h).to eq(hash)
+  end
+
+  it 'should initialize and convert Quote message correctly' do
+    hash = {
+      "type": 'Quote',
+      "id": 123456,
+      "groupId": 123456789,
+      "senderId": 987654321,
+      "targetId": 9876543210,
+      "origin": [
+        { "type": 'Plain', text: 'text' }.stringify_keys
+      ]
+    }.stringify_keys
+    qm = Rubirai::QuoteMessage.new hash
+    expect(qm.id).to eq(123456)
+    expect(qm.origin).to be_a(Rubirai::MessageChain)
+    expect(qm.origin.sender_id).to eq(987654321)
+    expect(qm.origin.messages).to be_a(Array)
+    expect(qm.origin.messages.length).to eq(1)
+    expect(qm.origin.messages[0]).to be_a(Rubirai::Message)
+    expect(qm.origin.messages[0].type).to eq(:Plain)
+    expect(qm.origin.messages[0].text).to eq('text')
+
+    expect(qm.to_h).to eq(hash)
+  end
+
+  it 'should initialize and convert At message correctly' do
+    hash = {
+      "type": 'At',
+      "target": 123456,
+      "display": '@Mirai'
+    }.stringify_keys
+    am = Rubirai::AtMessage.new hash
+    expect(am.type).to eq(:At)
+    expect(am.target).to eq(123456)
+    expect(am.display).to eq('@Mirai')
+
+    expect(am.to_h).to eq(hash)
+    expect(Rubirai::AtMessage.from(target: 114514).to_h).to eq({
+      'type' => 'At',
+      'target' => 114514
+    })
+  end
+
+  it 'should initialize and convert AtAll message correctly' do
+    hash = { 'type' => 'AtAll' }
+    aam = Rubirai::AtAllMessage.new hash
+    expect(aam.type).to eq(:AtAll)
+    expect(aam.bot).to eq(nil)
+
+    expect(aam.to_h).to eq(hash)
+  end
+
+  it 'should initialize and convert Face message correctly' do
+    hash = {
+      "type": 'Face',
+      "faceId": 123,
+      "name": 'bu'
+    }.stringify_keys
+    fm = Rubirai::FaceMessage.new hash
+    expect(fm.type).to eq(:Face)
+    expect(fm.face_id).to eq(123)
+    expect(fm.name).to eq('bu')
+
+    expect(fm.to_h).to eq(hash)
+  end
+
+  it 'should initialize and convert Plain message correctly' do
+    hash = {
+      "type": 'Plain',
+      "text": 'Mirai牛逼'
+    }.stringify_keys
+    pm = Rubirai::PlainMessage.new hash
+    expect(pm.type).to eq(:Plain)
+    expect(pm.text).to eq('Mirai牛逼')
+
+    expect(pm.to_h).to eq(hash)
+  end
+
+  it 'should initialize and convert Image message correctly' do
+    hash = {
+      "type": 'Image',
+      "imageId": '{01E9451B-70ED-EAE3-B37C-101F1EEBF5B5}.mirai',
+      "path": nil
+    }.stringify_keys
+    im = Rubirai::ImageMessage.new hash
+    expect(im.type).to eq(:Image)
+    expect(im.path).to be_nil
+    expect(im.image_id).to eq(hash['imageId'])
+
+    expect(im.to_h).to eq(hash.compact)
+  end
+
+  it 'should initialize and convert music share message correctly' do
+    hash = {
+      "type": 'MusicShare',
+      "kind": 'NeteaseCloudMusic',
+      "title": '相见恨晚',
+      "summary": '彭佳慧',
+      "jumpUrl": 'https://y.music.163.com/m/song/280761/',
+      "pictureUrl": 'http://p4.music.126.net/GpsgjHB_9XgtrBVXt8XX4w==/93458488373078.jpg',
+      "musicUrl": 'http://music.163.com/song/media/outer/url?id=280761&userid=52707509',
+      "brief": '[分享]相见恨晚'
+    }.stringify_keys
+    msm = Rubirai::MusicShareMessage.new hash
+    expect(msm.type).to eq(:MusicShare)
+    expect(msm.kind).to eq(hash['kind'])
+    expect(msm.jump_url).to eq(hash['jumpUrl'])
+    expect(msm.music_url).to eq(hash['musicUrl'])
+  end
+
+  it 'should build correctly from hash' do
+    hash = {
+      "type": 'Face',
+      "faceId": 123,
+      "name": 'bu'
+    }.stringify_keys
+    msg = Rubirai::Message.build_from hash
+    expect(msg).to be_a(Rubirai::FaceMessage)
+    expect(msg.to_h).to eq(hash)
+
+    bot = Rubirai::Bot.new 'test'
+    hash = {
+      "type": 'Quote',
+      "id": 123456,
+      "groupId": 123456789,
+      "senderId": 987654321,
+      "targetId": 9876543210,
+      "origin": [
+        { "type": 'Plain', text: 'text' }.stringify_keys
+      ]
+    }.stringify_keys
+    msg = Rubirai::Message.build_from hash, bot
+    expect(msg).to be_a(Rubirai::QuoteMessage)
+    expect(msg.bot).to eq(bot)
+    expect(msg.to_h).to eq(hash)
+  end
+
+  it 'should have kind of constructor methods' do
+    Rubirai::Message.all_types.each do |type|
+      expect(Rubirai.class.method_defined?("#{type}Message")).to be_truthy
+    end
+
+    am = Rubirai::AtMessage(target: 123456)
+    expect(am).to be_a(Rubirai::AtMessage)
+    expect(am.target).to eq(123456)
+  end
+end

data/spec/plugin_info_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'plugin info api' do
+  before do
+    @mirai_bot = new_bot
+  end
+
+  after do
+    # Do nothing
+  end
+
+  it 'should return the plugin info' do
+    stub_request(:get, @mirai_bot.gen_uri('/about'))
+      .to_return(status: 200, body: '{
+          "code": 0,
+          "errorMessage": "",
+          "data": {
+              "version": "v1.0.0"
+          }
+      }')
+    res = @mirai_bot.about
+    expect(res).to be_a_kind_of(Hash)
+    expect(res).to have_key('version')
+    expect(res['version']).to eq('v1.0.0')
+  end
+end

data/spec/rubirai_bot_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'rubirai bot' do
+  before do
+    # Do nothing
+  end
+
+  after do
+    # Do nothing
+  end
+
+  it 'should be able to generate a new bot' do
+    res = Rubirai::Bot.new 'test', 123
+    expect(res).to be_a_kind_of(Rubirai::Bot)
+  end
+
+  it 'should generate correct uri' do
+    bot = Rubirai::Bot.new 'test_hostname', 1145
+    uri = bot.gen_uri('path')
+    expect(uri).to be_a_kind_of(URI::HTTP)
+    expect(uri.to_s).to eq('http://test_hostname:1145/path')
+
+    expect(bot.gen_uri('/a/').to_s).to eq('http://test_hostname:1145/a/')
+
+    bot = Rubirai::Bot.new 'host'
+    expect(bot.gen_uri('/b').to_s).to eq('http://host/b')
+  end
+
+  it 'should check types' do
+    bot = Rubirai::Bot
+    expect { bot.ensure_type_in(:x, *%i[x y z]) }.not_to raise_error
+    expect { bot.ensure_type_in(:x, :X) }.not_to raise_error
+    expect { bot.ensure_type_in(:xAb, *%i[XaB Y z]) }.not_to raise_error
+    expect { bot.ensure_type_in(:x, *%i[y z]) }.to raise_error(
+      Rubirai::RubiraiError,
+      'not valid type: should be one of ["y", "z"]'
+    )
+    expect { bot.ensure_type_in(:x, :y) }.to raise_error(
+      Rubirai::RubiraiError,
+      'not valid type: should be one of ["y"]'
+    )
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'simplecov'
+SimpleCov.start do
+  project_name 'rubirai'
+  track_files 'lib/**/*.rb'
+  add_filter '/spec/'
+end
+
+if ENV['CI'] == 'true'
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
+
+require 'webmock/rspec'
+require 'rspec'
+require 'rubirai'
+
+def new_bot
+  Rubirai::Bot.new('test')
+end
+
+WebMock.disable_net_connect!(allow_localhost: false)
+
+RSpec.configure do |config|
+  config.before :all do
+    @auth_key = 'test_auth_key'
+    @session_key = 'test_session_key'
+    @qq = 1145141919
+  end
+end

data/spec/utils_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'errors' do
+  it 'stringifies keys' do
+    original = {
+      a: 3,
+      b: 4,
+      'c' => 5,
+      D: 6
+    }
+    expected = {
+      'a' => 3,
+      'b' => 4,
+      'c' => 5,
+      'D' => 6
+    }
+    expect(original.stringify_keys).to eq(expected)
+
+    original.stringify_keys!
+
+    expect(original).to eq(expected)
+  end
+
+  it 'symbolizes keys' do
+    original = {
+      'a' => 3,
+      'b' => 4,
+      :c => 5,
+      'D' => 6,
+      :E => 7
+    }
+    expected = {
+      a: 3,
+      b: 4,
+      c: 5,
+      D: 6,
+      E: 7
+    }
+
+    expect(original.symbolize_keys).to eq(expected)
+
+    original.symbolize_keys!
+
+    expect(original).to eq(expected)
+  end
+
+  it 'transforms to camel case' do
+    expect('SnakE_cAsE'.snake_to_camel).to eq('SnakeCase')
+    expect('SnakE_cAsE'.snake_to_camel(lower: true)).to eq('snakeCase')
+
+    expect('cat'.snake_to_camel).to eq('Cat')
+    expect('cAT'.snake_to_camel).to eq('Cat')
+    expect('CaT'.snake_to_camel).to eq('Cat')
+    expect('cat'.snake_to_camel(lower: true)).to eq('cat')
+    expect('cAT'.snake_to_camel(lower: true)).to eq('cat')
+    expect('CaT'.snake_to_camel(lower: true)).to eq('cat')
+  end
+
+  it 'checks type' do
+    expect { 'cat'.must_be! String }.not_to raise_error
+    expect { { a: 3 }.must_be! [Array, Hash] }.not_to raise_error
+    expect { 'cat'.must_be! Array }.to raise_error(RuntimeError, 'assert failed: `cat\' must be of type Array')
+    expect do
+      'cat'.must_be! [Array, Hash]
+    end.to raise_error(RuntimeError, 'assert failed: `cat\' must be of type [Array, Hash]')
+    expect { 'cat'.must_be! Array, ArgumentError, 'argument error' }.to raise_error(ArgumentError, 'argument error')
+  end
+end