zstd-ruby/spec/zstd-ruby_spec.rb at b2861cf5257fc2bbbb7017bb14a0b4cd8cb48575 · SpringMT/zstd-ruby · GitHub

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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
require "spec_helper"
require 'zstd-ruby'
require 'securerandom'

RSpec.describe Zstd do
  let(:user_json) do
    File.read("#{__dir__}/user_springmt.json")
  end

  it "has a version number" do
    expect(Zstd::VERSION).not_to be nil
  end

  describe 'zstd_version' do
    it 'should work' do
      expect(Zstd.zstd_version).to eq(10507)
    end
  end

  describe 'compress' do
    it 'should work' do
      compressed = Zstd.compress(user_json)
      expect(compressed).to be_a(String)
      expect(compressed).to_not eq(user_json)
    end

    it 'should support compression keyward args levels' do
      compressed = Zstd.compress(user_json, level: 1)
      compressed_default = Zstd.compress(user_json)
      expect(compressed).to be_a(String)
      expect(compressed).to_not eq(user_json)
      expect(compressed).to_not eq(compressed_default)
      expect(compressed_default.length).to be < compressed.length
    end

    it 'should compress large bytes' do
      large_string = Random.bytes(1<<17 + 15)
      compressed = Zstd.compress(large_string)
      expect(Zstd.decompress(compressed)).to eq(large_string)
    end

    it 'should raise exception with unsupported object' do
      expect { Zstd.compress(Object.new) }.to raise_error(TypeError)
    end

    class DummyForCompress
      def to_str
        'abc'
      end
    end

    it 'should convert object implicitly' do
      compressed = Zstd.compress(DummyForCompress.new)
      expect(compressed).to be_a(String)
      decompressed = Zstd.decompress(compressed)
      expect(decompressed).to eq('abc')
    end
  end

  describe 'decompress' do
    it 'should work' do
      # bounbdary is 128 bytes
      str = SecureRandom.hex(150)
      compressed = Zstd.compress(str)
      decompressed = Zstd.decompress(compressed)
      expect(decompressed).to eq(str)
    end

    it 'should work for empty strings' do
      compressed = Zstd.compress('')
      expect(compressed.bytesize).to eq(9)
      decompressed = Zstd.decompress(compressed)
      expect(decompressed).to eq('')
    end

    it 'should work for non-ascii string' do
      compressed = Zstd.compress('あああ')
      expect(compressed.bytesize).to eq(18)
      decompressed = Zstd.decompress(compressed)
      expect(decompressed.force_encoding('UTF-8')).to eq('あああ')
    end

    it 'should work hash equal streaming compress' do
      simple_compressed = Zstd.compress('あ')
      stream = Zstd::StreamingCompress.new
      stream << "あ"
      streaming_compressed = stream.finish
      expect(Zstd.decompress(simple_compressed).force_encoding('UTF-8').hash).to eq(Zstd.decompress(streaming_compressed).force_encoding('UTF-8').hash)
    end

    it 'shoud work with large streaming compress data' do
      large_strings = Random.bytes(1<<16)
      stream = Zstd::StreamingCompress.new
      res = stream.compress(large_strings)
      res << stream.flush
      res << stream.compress(large_strings)
      res << stream.compress(large_strings)
      res << stream.finish
      expect(Zstd.decompress(res)).to eq(large_strings * 3)
    end

    it 'should raise exception with unsupported object' do
      expect { Zstd.decompress(Object.new) }.to raise_error(TypeError)
    end

    class DummyForDecompress
      def to_str
        Zstd.compress('abc')
      end
    end

    it 'should convert object implicitly' do
      expect(Zstd.decompress(DummyForDecompress.new)).to eq('abc')
    end
  end

  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0')
    describe 'Ractor' do
      it 'should be supported' do
        r = Ractor.new { Zstd.compress('abc') }
        expect(Zstd.decompress(r.take)).to eq('abc')
      end
    end
  end
end