minitar 1.0.2 → 1.1.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/CHANGELOG.md +326 -0
- data/CODE_OF_CONDUCT.md +167 -0
- data/CONTRIBUTING.md +312 -0
- data/CONTRIBUTORS.md +27 -0
- data/LICENCE.md +42 -0
- data/Manifest.txt +31 -8
- data/README.md +82 -0
- data/Rakefile +74 -20
- data/SECURITY.md +54 -0
- data/lib/minitar/input.rb +242 -189
- data/lib/minitar/output.rb +72 -64
- data/lib/minitar/pax_header.rb +111 -0
- data/lib/minitar/posix_header.rb +276 -239
- data/lib/minitar/reader.rb +226 -231
- data/lib/minitar/version.rb +5 -0
- data/lib/minitar/writer.rb +246 -299
- data/lib/minitar.rb +134 -115
- data/licenses/bsdl.txt +20 -0
- data/licenses/dco.txt +34 -0
- data/licenses/ruby.txt +52 -0
- data/test/fixtures/issue_46.tar.gz +0 -0
- data/test/fixtures/issue_62.tar.gz +0 -0
- data/test/fixtures/tar_input.tgz +0 -0
- data/test/fixtures/test_input_non_strict_octal.tgz +0 -0
- data/test/fixtures/test_input_relative.tgz +0 -0
- data/test/fixtures/test_input_space_octal.tgz +0 -0
- data/test/fixtures/test_minitar.tar.gz +0 -0
- data/test/minitest_helper.rb +12 -1
- data/test/support/minitar_test_helpers/fixtures.rb +38 -0
- data/test/support/minitar_test_helpers/header.rb +130 -0
- data/test/support/minitar_test_helpers/tarball.rb +324 -0
- data/test/support/minitar_test_helpers.rb +36 -0
- data/test/test_filename_boundary_conditions.rb +74 -0
- data/test/test_gnu_tar_compatibility.rb +92 -0
- data/test/test_integration_pack_unpack_cycle.rb +38 -0
- data/test/test_issue_46.rb +5 -23
- data/test/test_issue_62.rb +50 -0
- data/test/test_minitar.rb +168 -39
- data/test/test_path_normalization.rb +170 -0
- data/test/test_pax_header.rb +104 -0
- data/test/test_pax_support.rb +66 -0
- data/test/test_tar_header.rb +289 -75
- data/test/test_tar_input.rb +14 -61
- data/test/test_tar_output.rb +7 -9
- data/test/test_tar_reader.rb +17 -18
- data/test/test_tar_writer.rb +105 -126
- data/test/test_windows_extraction.rb +121 -0
- metadata +108 -95
- data/Code-of-Conduct.md +0 -128
- data/Contributing.md +0 -94
- data/History.md +0 -236
- data/Licence.md +0 -15
- data/README.rdoc +0 -92
- data/docs/bsdl.txt +0 -19
- data/docs/ruby.txt +0 -56
- data/test/support/tar_test_helpers.rb +0 -134
data/test/test_minitar.rb
CHANGED
|
@@ -1,60 +1,189 @@
|
|
|
1
|
-
|
|
1
|
+
# frozen_string_literal: true
|
|
2
2
|
|
|
3
|
-
require "minitar"
|
|
4
3
|
require "minitest_helper"
|
|
5
|
-
require "zlib"
|
|
6
4
|
|
|
7
5
|
class TestMinitar < Minitest::Test
|
|
8
|
-
|
|
6
|
+
SCENARIO = {
|
|
7
|
+
"path" => nil,
|
|
8
|
+
"test" => "test",
|
|
9
|
+
"extra/test" => "extra/test",
|
|
10
|
+
"empty2004" => {mtime: TIME_2004, mode: 0o755, data: ""},
|
|
11
|
+
"notime" => {mtime: nil, data: "notime"}
|
|
12
|
+
}
|
|
9
13
|
|
|
10
|
-
def
|
|
11
|
-
|
|
12
|
-
["path", nil],
|
|
13
|
-
["test", "test"],
|
|
14
|
-
["extra/test", "extra/test"],
|
|
15
|
-
[{name: "empty2004", mtime: FILE_2004, mode: 0o755}, ""]
|
|
16
|
-
]
|
|
14
|
+
def test_minitar_open_r
|
|
15
|
+
count = 0
|
|
17
16
|
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
17
|
+
open_fixture("test_minitar") do |fixture|
|
|
18
|
+
Minitar.open(fixture, "r") do |stream|
|
|
19
|
+
stream.each do |entry|
|
|
20
|
+
assert_kind_of Minitar::Reader::EntryStream, entry
|
|
21
|
+
|
|
22
|
+
assert SCENARIO.has_key?(entry.name), "#{entry.name} not expected"
|
|
23
|
+
|
|
24
|
+
expected = SCENARIO[entry.name]
|
|
25
|
+
|
|
26
|
+
case expected
|
|
27
|
+
when nil
|
|
28
|
+
assert_equal 0, entry.size
|
|
29
|
+
assert_modes_equal 0o755, entry.mode, entry.name
|
|
30
|
+
assert entry.directory?, "#{entry.name} should be a directory"
|
|
31
|
+
when String
|
|
32
|
+
assert_equal expected.length, entry.size, entry.name
|
|
33
|
+
assert_modes_equal 0o644, entry.mode, entry.name
|
|
34
|
+
assert entry.file?, "#{entry.name} should be a file"
|
|
35
|
+
|
|
36
|
+
if entry.size.zero?
|
|
37
|
+
assert_nil entry.read
|
|
38
|
+
else
|
|
39
|
+
assert_equal expected, entry.read
|
|
40
|
+
end
|
|
41
|
+
when Hash
|
|
42
|
+
if expected[:data].nil?
|
|
43
|
+
assert_equal 0, entry.size
|
|
44
|
+
assert_modes_equal (expected[:mode] || 0o755), entry.mode, entry.name
|
|
45
|
+
assert entry.directory?, "#{entry.name} should be a directory"
|
|
46
|
+
else
|
|
47
|
+
assert_equal expected[:data].length, entry.size
|
|
48
|
+
assert_modes_equal (expected[:mode] || 0o644), entry.mode, entry.name
|
|
49
|
+
assert entry.file?, "#{entry.name} should be a file"
|
|
50
|
+
end
|
|
51
|
+
|
|
52
|
+
assert_equal expected[:mtime], entry.mtime if expected[:mtime]
|
|
53
|
+
|
|
54
|
+
if entry.size.zero?
|
|
55
|
+
assert_nil entry.read
|
|
56
|
+
else
|
|
57
|
+
assert_equal expected[:data], entry.read
|
|
58
|
+
end
|
|
59
|
+
end
|
|
60
|
+
|
|
61
|
+
count += 1
|
|
62
|
+
end
|
|
22
63
|
end
|
|
23
64
|
end
|
|
24
65
|
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
{name: "test", size: 4, mode: 0o644, data: "test"},
|
|
28
|
-
{name: "extra/test", size: 10, mode: 0o0644, data: "extra/test"},
|
|
29
|
-
{name: "empty2004", size: 0, mode: 0o755, mtime: FILE_2004, nil: true}
|
|
30
|
-
]
|
|
66
|
+
assert_equal SCENARIO.size, count
|
|
67
|
+
end
|
|
31
68
|
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
Minitar.open(reader) do |stream|
|
|
35
|
-
stream.each.with_index do |entry, i|
|
|
36
|
-
assert_kind_of Minitar::Reader::EntryStream, entry
|
|
69
|
+
def test_minitar_open_w
|
|
70
|
+
events = []
|
|
37
71
|
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
72
|
+
writer = StringIO.new
|
|
73
|
+
Minitar.open(writer, "w") do |stream|
|
|
74
|
+
SCENARIO.each_pair do |name, data|
|
|
75
|
+
name, data =
|
|
76
|
+
if data.is_a?(Hash)
|
|
77
|
+
name = data.merge(name: name)
|
|
78
|
+
[name, name.delete(:data)]
|
|
79
|
+
else
|
|
80
|
+
[name, data]
|
|
81
|
+
end
|
|
41
82
|
|
|
42
|
-
|
|
43
|
-
|
|
83
|
+
Minitar.pack_as_file(name, data, stream) do |op, entry_name, stats|
|
|
84
|
+
events << {
|
|
85
|
+
name: name,
|
|
86
|
+
data: data,
|
|
87
|
+
op: op,
|
|
88
|
+
entry_name: entry_name,
|
|
89
|
+
stats: stats
|
|
90
|
+
}
|
|
44
91
|
end
|
|
92
|
+
end
|
|
93
|
+
end
|
|
45
94
|
|
|
46
|
-
|
|
47
|
-
assert_equal expected[i][:data], entry.read
|
|
48
|
-
end
|
|
95
|
+
assert_equal 5120, writer.string.length
|
|
49
96
|
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
97
|
+
events.each do |event|
|
|
98
|
+
if event[:name].is_a?(Hash)
|
|
99
|
+
assert_equal event[:name][:name], event[:entry_name]
|
|
100
|
+
else
|
|
101
|
+
assert_equal event[:name], event[:entry_name]
|
|
102
|
+
end
|
|
53
103
|
|
|
54
|
-
|
|
104
|
+
case [event[:op], event[:entry_name]]
|
|
105
|
+
in [:dir, "path"]
|
|
106
|
+
assert_equal 0, event[:stats][:size]
|
|
107
|
+
assert_equal 493, event[:stats][:mode]
|
|
108
|
+
|
|
109
|
+
in [:file_start, "test"]
|
|
110
|
+
assert_equal 4, event[:stats][:size]
|
|
111
|
+
assert_equal 420, event[:stats][:mode]
|
|
112
|
+
assert_equal 4, event[:stats][:current]
|
|
113
|
+
assert_equal 4, event[:stats][:currinc]
|
|
114
|
+
assert_equal "test", event[:data]
|
|
115
|
+
in [:file_progress, "test"]
|
|
116
|
+
assert_equal 4, event[:stats][:size]
|
|
117
|
+
assert_equal 420, event[:stats][:mode]
|
|
118
|
+
assert_equal 4, event[:stats][:current]
|
|
119
|
+
assert_equal 4, event[:stats][:currinc]
|
|
120
|
+
assert_equal "test", event[:data]
|
|
121
|
+
in [:file_done, "test"]
|
|
122
|
+
assert_equal 4, event[:stats][:size]
|
|
123
|
+
assert_equal 420, event[:stats][:mode]
|
|
124
|
+
assert_equal 4, event[:stats][:current]
|
|
125
|
+
assert_equal 4, event[:stats][:currinc]
|
|
126
|
+
assert_equal "test", event[:data]
|
|
127
|
+
|
|
128
|
+
in [:file_start, "extra/test"]
|
|
129
|
+
assert_equal 10, event[:stats][:size]
|
|
130
|
+
assert_equal 420, event[:stats][:mode]
|
|
131
|
+
assert_equal 10, event[:stats][:current]
|
|
132
|
+
assert_equal 10, event[:stats][:currinc]
|
|
133
|
+
assert_equal "extra/test", event[:data]
|
|
134
|
+
in [:file_progress, "extra/test"]
|
|
135
|
+
assert_equal 10, event[:stats][:size]
|
|
136
|
+
assert_equal 420, event[:stats][:mode]
|
|
137
|
+
assert_equal 10, event[:stats][:current]
|
|
138
|
+
assert_equal 10, event[:stats][:currinc]
|
|
139
|
+
assert_equal "extra/test", event[:data]
|
|
140
|
+
in [:file_done, "extra/test"]
|
|
141
|
+
assert_equal 10, event[:stats][:size]
|
|
142
|
+
assert_equal 420, event[:stats][:mode]
|
|
143
|
+
assert_equal 10, event[:stats][:current]
|
|
144
|
+
assert_equal 10, event[:stats][:currinc]
|
|
145
|
+
assert_equal "extra/test", event[:data]
|
|
146
|
+
|
|
147
|
+
in [:file_start, "empty2004"]
|
|
148
|
+
assert_equal 0, event[:stats][:size]
|
|
149
|
+
assert_equal 493, event[:stats][:mode]
|
|
150
|
+
assert_equal 0, event[:stats][:current]
|
|
151
|
+
assert_equal 1072915200, event[:stats][:mtime]
|
|
152
|
+
assert_equal "", event[:data]
|
|
153
|
+
in [:file_done, "empty2004"]
|
|
154
|
+
assert_equal 0, event[:stats][:size]
|
|
155
|
+
assert_equal 493, event[:stats][:mode]
|
|
156
|
+
assert_equal 0, event[:stats][:current]
|
|
157
|
+
assert_equal 1072915200, event[:stats][:mtime]
|
|
158
|
+
assert_equal "", event[:data]
|
|
159
|
+
|
|
160
|
+
in [:file_start, "notime"]
|
|
161
|
+
assert_equal 6, event[:stats][:size]
|
|
162
|
+
assert_equal 420, event[:stats][:mode]
|
|
163
|
+
assert_equal 6, event[:stats][:current]
|
|
164
|
+
assert_equal 6, event[:stats][:currinc]
|
|
165
|
+
assert_equal "notime", event[:data]
|
|
166
|
+
in [:file_progress, "notime"]
|
|
167
|
+
assert_equal 6, event[:stats][:size]
|
|
168
|
+
assert_equal 420, event[:stats][:mode]
|
|
169
|
+
assert_equal 6, event[:stats][:current]
|
|
170
|
+
assert_equal 6, event[:stats][:currinc]
|
|
171
|
+
assert_equal "notime", event[:data]
|
|
172
|
+
in [:file_done, "notime"]
|
|
173
|
+
assert_equal 6, event[:stats][:size]
|
|
174
|
+
assert_equal 420, event[:stats][:mode]
|
|
175
|
+
assert_equal 6, event[:stats][:current]
|
|
176
|
+
assert_equal 6, event[:stats][:currinc]
|
|
177
|
+
assert_equal "notime", event[:data]
|
|
178
|
+
else
|
|
179
|
+
raise "Unknown operation #{event[:op].inspect} for #{event[:entry_name].inspect}"
|
|
55
180
|
end
|
|
56
181
|
end
|
|
182
|
+
end
|
|
57
183
|
|
|
58
|
-
|
|
184
|
+
def test_minitar_x
|
|
185
|
+
assert_raises(ArgumentError) do
|
|
186
|
+
Minitar.open("foo", "x")
|
|
187
|
+
end
|
|
59
188
|
end
|
|
60
189
|
end
|
|
@@ -0,0 +1,170 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require "minitest_helper"
|
|
4
|
+
|
|
5
|
+
# Tests the private name normalization and relative path checks. These run on every
|
|
6
|
+
# platform because the alternate separator is passed as a parameter.
|
|
7
|
+
class TestPathNormalization < Minitest::Test
|
|
8
|
+
def input
|
|
9
|
+
@input ||= Minitar::Input.allocate
|
|
10
|
+
end
|
|
11
|
+
|
|
12
|
+
def normalize(name, alt_separator)
|
|
13
|
+
input.send(:normalize_entry_name, name, alt_separator)
|
|
14
|
+
end
|
|
15
|
+
|
|
16
|
+
def check(name)
|
|
17
|
+
input.send(:check_relative_path!, name)
|
|
18
|
+
end
|
|
19
|
+
|
|
20
|
+
# --- check_relative_path! (all platforms) ---
|
|
21
|
+
|
|
22
|
+
def test_check_rejects_parent_components
|
|
23
|
+
[
|
|
24
|
+
"..", "../x", "a/..", "a/../b", "a/../../x", "a/b/.."
|
|
25
|
+
].each do |name|
|
|
26
|
+
assert_raises(Minitar::SecureRelativePathError, name) { check(name) }
|
|
27
|
+
end
|
|
28
|
+
end
|
|
29
|
+
|
|
30
|
+
def test_check_accepts_dots_within_a_component
|
|
31
|
+
[
|
|
32
|
+
"dirname../x", "..dirname/x", "a/dirname..", "a/..b/c", "...", "a/.../b", "a..b/c",
|
|
33
|
+
".hidden/x", "a/./b"
|
|
34
|
+
].each do |name|
|
|
35
|
+
check(name)
|
|
36
|
+
end
|
|
37
|
+
|
|
38
|
+
pass
|
|
39
|
+
end
|
|
40
|
+
|
|
41
|
+
# --- nil alt_separator (POSIX): nothing but squeeze ---
|
|
42
|
+
|
|
43
|
+
def test_nil_separator_keeps_backslashes_literal
|
|
44
|
+
[
|
|
45
|
+
"..\\x", "a\\..\\..\\x", "a\\..\\b", "..\\/x", "C:\\x", "C:x", "C:/x",
|
|
46
|
+
"\\\\host\\share\\x", "a\\b", "a.txt:stream", "...\\x", "dirname..\\x", "a. \\x"
|
|
47
|
+
].each do |name|
|
|
48
|
+
assert_equal name, normalize(name, nil)
|
|
49
|
+
check(name)
|
|
50
|
+
end
|
|
51
|
+
end
|
|
52
|
+
|
|
53
|
+
def test_nil_separator_squeezes_slashes
|
|
54
|
+
assert_equal "a/b/c", normalize("a//b///c", nil)
|
|
55
|
+
end
|
|
56
|
+
|
|
57
|
+
# --- "\\" alt_separator (Windows semantics) ---
|
|
58
|
+
|
|
59
|
+
def test_backslash_separator_rejects_traversal
|
|
60
|
+
[
|
|
61
|
+
"..\\x", "a\\..\\..\\x", "a\\..\\b", "..\\/x", "../x", "a/..\\x", "a\\..",
|
|
62
|
+
"\\..\\x", "\\dir\\..\\x", "dir\\..\\..\\x"
|
|
63
|
+
].each do |name|
|
|
64
|
+
assert_raises(Minitar::SecureRelativePathError, name) {
|
|
65
|
+
check(normalize(name, "\\"))
|
|
66
|
+
}
|
|
67
|
+
end
|
|
68
|
+
end
|
|
69
|
+
|
|
70
|
+
def test_backslash_separator_rejects_dot_only_components
|
|
71
|
+
[
|
|
72
|
+
"...\\x", "....\\x", "a\\...\\b", "a\\...", ".. \\x", ".. .\\x", "a\\.. "
|
|
73
|
+
].each do |name|
|
|
74
|
+
assert_raises(Minitar::UnsafeFileNameError, name) { normalize(name, "\\") }
|
|
75
|
+
end
|
|
76
|
+
end
|
|
77
|
+
|
|
78
|
+
def test_backslash_separator_leaves_dot_and_dotdot_components_to_the_path_check
|
|
79
|
+
assert_equal "a/./b", normalize("a\\.\\b", "\\")
|
|
80
|
+
assert_equal "a/../b", normalize("a\\..\\b", "\\")
|
|
81
|
+
end
|
|
82
|
+
|
|
83
|
+
def test_backslash_separator_preserves_interior_dots
|
|
84
|
+
[
|
|
85
|
+
"a..b..c.txt", "a..b\\c.txt", "..a\\c.txt"
|
|
86
|
+
].each do |name|
|
|
87
|
+
assert_equal name.tr("\\", "/"), normalize(name, "\\")
|
|
88
|
+
end
|
|
89
|
+
end
|
|
90
|
+
|
|
91
|
+
def test_backslash_separator_rejects_trailing_dots_and_spaces
|
|
92
|
+
[
|
|
93
|
+
"dirname..\\x", "dir.\\x", "dir \\x", "a\\file.", "a\\file ", "foo...\\x"
|
|
94
|
+
].each do |name|
|
|
95
|
+
assert_raises(Minitar::UnsafeFileNameError, name) { normalize(name, "\\") }
|
|
96
|
+
end
|
|
97
|
+
end
|
|
98
|
+
|
|
99
|
+
def test_backslash_separator_accepts_ordinary_dots
|
|
100
|
+
assert_equal "a/./b", normalize("a\\.\\b", "\\")
|
|
101
|
+
assert_equal "dir..name/.hidden/a.b.txt/", normalize("dir..name\\.hidden\\a.b.txt\\", "\\")
|
|
102
|
+
end
|
|
103
|
+
|
|
104
|
+
def test_backslash_separator_converts_and_squeezes
|
|
105
|
+
assert_equal "a/b", normalize("a\\b", "\\")
|
|
106
|
+
assert_equal "a/b/c/d", normalize("a\\\\b//c\\/d", "\\")
|
|
107
|
+
end
|
|
108
|
+
|
|
109
|
+
def test_backslash_separator_rejects_drive_names
|
|
110
|
+
[
|
|
111
|
+
"C:\\x", "C:x", "C:/x", "c:\\x", "C:", "a\\C:\\x"
|
|
112
|
+
].each do |name|
|
|
113
|
+
assert_raises(Minitar::UnsafeFileNameError, name) { normalize(name, "\\") }
|
|
114
|
+
end
|
|
115
|
+
end
|
|
116
|
+
|
|
117
|
+
def test_backslash_separator_turns_unc_names_into_relative_paths
|
|
118
|
+
{
|
|
119
|
+
"\\\\host\\share\\x" => "/host/share/x",
|
|
120
|
+
"//host/share/x" => "/host/share/x",
|
|
121
|
+
"\\/host/share" => "/host/share",
|
|
122
|
+
"\\\\host" => "/host"
|
|
123
|
+
}.each do |name, expected|
|
|
124
|
+
assert_equal expected, normalize(name, "\\")
|
|
125
|
+
check(expected)
|
|
126
|
+
end
|
|
127
|
+
end
|
|
128
|
+
|
|
129
|
+
def test_backslash_separator_rejects_alternate_data_streams
|
|
130
|
+
[
|
|
131
|
+
"a.txt:stream", "dir/a.txt:stream:$DATA", "dir:x/a", "a\\b:s"
|
|
132
|
+
].each do |name|
|
|
133
|
+
assert_raises(Minitar::UnsafeFileNameError, name) { normalize(name, "\\") }
|
|
134
|
+
end
|
|
135
|
+
end
|
|
136
|
+
|
|
137
|
+
def test_unsafe_file_name_error_is_a_minitar_error
|
|
138
|
+
assert_operator Minitar::UnsafeFileNameError, :<, Minitar::Error
|
|
139
|
+
end
|
|
140
|
+
|
|
141
|
+
# --- end-to-end on POSIX: guards against over-normalizing ---
|
|
142
|
+
|
|
143
|
+
def test_posix_extraction_keeps_backslash_names_literal
|
|
144
|
+
skip "POSIX only" if Minitar.windows_separator?
|
|
145
|
+
|
|
146
|
+
names = ["..\\x", "a\\..\\..\\x", "a\\b", "dirname../x"]
|
|
147
|
+
Dir.mktmpdir do |root|
|
|
148
|
+
dest = File.join(root, "dest")
|
|
149
|
+
Minitar.unpack(tar_with(names), dest)
|
|
150
|
+
|
|
151
|
+
assert_equal names.map { _1.sub(%r{/.*}, "") }.uniq.sort, Dir.children(dest).sort
|
|
152
|
+
assert_path_exists File.join(dest, "..\\x")
|
|
153
|
+
assert_path_exists File.join(dest, "dirname..", "x")
|
|
154
|
+
assert_equal ["dest"], Dir.children(root)
|
|
155
|
+
end
|
|
156
|
+
end
|
|
157
|
+
|
|
158
|
+
private
|
|
159
|
+
|
|
160
|
+
def tar_with(names)
|
|
161
|
+
io = StringIO.new(+"".b)
|
|
162
|
+
Minitar::Writer.open(io) do |w|
|
|
163
|
+
names.each do |name|
|
|
164
|
+
w.add_file_simple(name, mode: 0o644, size: 1) { _1.write("x") }
|
|
165
|
+
end
|
|
166
|
+
end
|
|
167
|
+
io.rewind
|
|
168
|
+
io
|
|
169
|
+
end
|
|
170
|
+
end
|
|
@@ -0,0 +1,104 @@
|
|
|
1
|
+
require "minitest_helper"
|
|
2
|
+
|
|
3
|
+
class TestPaxHeader < Minitest::Test
|
|
4
|
+
def test_from_stream_with_size_attribute
|
|
5
|
+
pax_content = "19 size=8614356715\n28 mtime=1749098832.3200000\n"
|
|
6
|
+
pax_header = create_pax_header_from_stream(pax_content)
|
|
7
|
+
|
|
8
|
+
assert_equal 8614356715, pax_header.size
|
|
9
|
+
assert_equal "1749098832.3200000", pax_header.attributes["mtime"]
|
|
10
|
+
end
|
|
11
|
+
|
|
12
|
+
def test_from_stream_without_size_attribute
|
|
13
|
+
pax_content = "28 mtime=1749098832.3200000\n27 path=some/long/path.txt\n"
|
|
14
|
+
pax_header = create_pax_header_from_stream(pax_content)
|
|
15
|
+
|
|
16
|
+
assert_nil pax_header.size
|
|
17
|
+
assert_equal "some/long/path.txt", pax_header.path
|
|
18
|
+
assert_equal 1749098832.32, pax_header.mtime
|
|
19
|
+
end
|
|
20
|
+
|
|
21
|
+
def test_parse_multiline_values
|
|
22
|
+
pax_content = "22 foo=one\ntwo\nthree\n\n12 bar=four\n"
|
|
23
|
+
pax_header = Minitar::PaxHeader.from_data(pax_content)
|
|
24
|
+
assert_equal "one\ntwo\nthree\n", pax_header.attributes["foo"]
|
|
25
|
+
assert_equal "four", pax_header.attributes["bar"]
|
|
26
|
+
end
|
|
27
|
+
|
|
28
|
+
def test_from_stream_with_invalid_header
|
|
29
|
+
header_data = build_tar_file_header("regular_file.txt", "", 0o644, 100)
|
|
30
|
+
io = StringIO.new(header_data)
|
|
31
|
+
|
|
32
|
+
posix_header = Minitar::PosixHeader.from_stream(io)
|
|
33
|
+
refute posix_header.pax_header?
|
|
34
|
+
|
|
35
|
+
assert_raises(ArgumentError, "Header must be a PAX header") do
|
|
36
|
+
Minitar::PaxHeader.from_stream(io, posix_header)
|
|
37
|
+
end
|
|
38
|
+
end
|
|
39
|
+
|
|
40
|
+
def test_parse_content_with_multiple_attributes
|
|
41
|
+
pax_content = "19 size=8614356715\n28 mtime=1749098832.3200000\n27 path=some/long/path.txt\n"
|
|
42
|
+
|
|
43
|
+
pax_header = Minitar::PaxHeader.from_data(pax_content)
|
|
44
|
+
|
|
45
|
+
assert_equal 8614356715, pax_header.size
|
|
46
|
+
assert_equal "some/long/path.txt", pax_header.path
|
|
47
|
+
assert_equal 1749098832.32, pax_header.mtime
|
|
48
|
+
|
|
49
|
+
# Check raw attributes
|
|
50
|
+
assert_equal "8614356715", pax_header.attributes["size"]
|
|
51
|
+
assert_equal "1749098832.3200000", pax_header.attributes["mtime"]
|
|
52
|
+
assert_equal "some/long/path.txt", pax_header.attributes["path"]
|
|
53
|
+
end
|
|
54
|
+
|
|
55
|
+
def test_parse_content_with_invalid_length_format
|
|
56
|
+
assert_raises(ArgumentError) do
|
|
57
|
+
Minitar::PaxHeader.from_data("19 size=8614356715\ninvalid line\n23 path=valid/path.txt\n")
|
|
58
|
+
end
|
|
59
|
+
end
|
|
60
|
+
|
|
61
|
+
def test_parse_content_with_oversized_record
|
|
62
|
+
assert_raises(ArgumentError) do
|
|
63
|
+
Minitar::PaxHeader.from_data("19 size=8614356715\n999 toolong=value\n")
|
|
64
|
+
end
|
|
65
|
+
end
|
|
66
|
+
|
|
67
|
+
def test_from_stream_strips_padding
|
|
68
|
+
pax_content = "19 size=8614356715\n"
|
|
69
|
+
pax_header = create_pax_header_from_stream(pax_content)
|
|
70
|
+
|
|
71
|
+
# Should parse only the actual content, ignoring padding
|
|
72
|
+
assert_equal 8614356715, pax_header.size
|
|
73
|
+
assert_equal 1, pax_header.attributes.size # Only one attribute parsed
|
|
74
|
+
|
|
75
|
+
# Should have parsed content correctly
|
|
76
|
+
assert_equal 1, pax_header.attributes.size
|
|
77
|
+
assert_equal "8614356715", pax_header.attributes["size"]
|
|
78
|
+
end
|
|
79
|
+
|
|
80
|
+
def test_attributes_accessor
|
|
81
|
+
pax_content = "19 size=8614356715\n23 custom=custom_value\n"
|
|
82
|
+
pax_header = Minitar::PaxHeader.from_data(pax_content)
|
|
83
|
+
|
|
84
|
+
assert_equal "8614356715", pax_header.attributes["size"]
|
|
85
|
+
assert_equal "custom_value", pax_header.attributes["custom"]
|
|
86
|
+
assert_nil pax_header.attributes["nonexistent"]
|
|
87
|
+
end
|
|
88
|
+
|
|
89
|
+
def test_pax_header_to_s
|
|
90
|
+
pax_header = Minitar::PaxHeader.new(size: "8614356715", mtime: "1749098832.3200000")
|
|
91
|
+
assert_equal "19 size=8614356715\n28 mtime=1749098832.3200000\n", pax_header.to_s
|
|
92
|
+
end
|
|
93
|
+
|
|
94
|
+
private
|
|
95
|
+
|
|
96
|
+
def create_pax_header_from_stream(pax_content, name = "./PaxHeaders.X/test_file")
|
|
97
|
+
pax_header_data = build_tar_pax_header(name, "", pax_content.bytesize)
|
|
98
|
+
padded_content = pax_content.ljust((pax_content.bytesize / 512.0).ceil * 512, "\0")
|
|
99
|
+
io = StringIO.new(pax_header_data + padded_content)
|
|
100
|
+
|
|
101
|
+
posix_header = Minitar::PosixHeader.from_stream(io)
|
|
102
|
+
Minitar::PaxHeader.from_stream(io, posix_header)
|
|
103
|
+
end
|
|
104
|
+
end
|
|
@@ -0,0 +1,66 @@
|
|
|
1
|
+
require "minitest_helper"
|
|
2
|
+
|
|
3
|
+
class TestPaxSupport < Minitest::Test
|
|
4
|
+
def test_pax_header_size_extraction_in_reader
|
|
5
|
+
pax_content = "16 size=1048576\n28 mtime=1749098832.3200000\n"
|
|
6
|
+
tar_data = create_pax_with_file_headers(pax_content, "./PaxHeaders.X/large_file.mov", "large_file.mov", 1048576, 0)
|
|
7
|
+
|
|
8
|
+
entries = read_tar_entries(tar_data)
|
|
9
|
+
assert_equal 1, entries.size
|
|
10
|
+
|
|
11
|
+
entry = entries.first
|
|
12
|
+
assert_equal "large_file.mov", entry.name
|
|
13
|
+
assert_equal 1048576, entry.size # Size from PAX header
|
|
14
|
+
end
|
|
15
|
+
|
|
16
|
+
def test_pax_header_without_size_uses_header_size
|
|
17
|
+
pax_content = "28 mtime=1749098832.3200000\n"
|
|
18
|
+
tar_data = create_pax_with_file_headers(pax_content, "./PaxHeaders.X/normal_file.txt", "normal_file.txt", 12345, 12345)
|
|
19
|
+
|
|
20
|
+
entries = read_tar_entries(tar_data)
|
|
21
|
+
assert_equal 1, entries.size
|
|
22
|
+
|
|
23
|
+
entry = entries.first
|
|
24
|
+
assert_equal "normal_file.txt", entry.name
|
|
25
|
+
assert_equal 12345, entry.size # Original header size preserved
|
|
26
|
+
end
|
|
27
|
+
|
|
28
|
+
def test_pax_header_takes_precedence_over_posix_header_size
|
|
29
|
+
pax_content = "16 size=1048576\n28 mtime=1749098832.3200000\n"
|
|
30
|
+
tar_data = create_pax_with_file_headers(pax_content, "./PaxHeaders.X/precedence_file.txt", "precedence_file.txt", 12345, 12345)
|
|
31
|
+
|
|
32
|
+
entries = read_tar_entries(tar_data)
|
|
33
|
+
assert_equal 1, entries.size
|
|
34
|
+
|
|
35
|
+
entry = entries.first
|
|
36
|
+
assert_equal "precedence_file.txt", entry.name
|
|
37
|
+
assert_equal 1048576, entry.size # PAX size takes precedence over POSIX size (12345)
|
|
38
|
+
end
|
|
39
|
+
|
|
40
|
+
def test_pax_size_extraction_logic
|
|
41
|
+
pax_header_with_size = Minitar::PaxHeader.new(size: "1048576", mtime: "1749098832.3200000")
|
|
42
|
+
assert_equal 1048576, pax_header_with_size.size
|
|
43
|
+
|
|
44
|
+
pax_header_without_size = Minitar::PaxHeader.new(mtime: "1749098832.3200000")
|
|
45
|
+
assert_nil pax_header_without_size.size
|
|
46
|
+
end
|
|
47
|
+
|
|
48
|
+
private
|
|
49
|
+
|
|
50
|
+
def read_tar_entries(tar_data)
|
|
51
|
+
io = StringIO.new(tar_data)
|
|
52
|
+
Minitar::Reader.open(io, &:to_a)
|
|
53
|
+
end
|
|
54
|
+
|
|
55
|
+
def create_pax_with_file_headers(pax_content, pax_name, file_name, file_size, posix_header_file_size)
|
|
56
|
+
file_content = "x" * file_size
|
|
57
|
+
padded_file_content = file_content.ljust((file_size / 512.0).ceil * 512, "\0")
|
|
58
|
+
|
|
59
|
+
[
|
|
60
|
+
build_tar_pax_header(pax_name, "", pax_content.bytesize),
|
|
61
|
+
pax_content.ljust((pax_content.bytesize / 512.0).ceil * 512, "\0"),
|
|
62
|
+
build_tar_file_header(file_name, "", 0o644, file_size),
|
|
63
|
+
padded_file_content
|
|
64
|
+
].join
|
|
65
|
+
end
|
|
66
|
+
end
|