func main() { flags := struct { help bool pretty bool inFile string outFile string }{} flag.BoolVar(&flags.help, "help", false, "print help and exit") flag.BoolVar(&flags.pretty, "pretty", false, "indent the output file") flag.StringVar(&flags.inFile, "in-file", "/dev/stdin", "input file (YAML)") flag.StringVar(&flags.outFile, "out-file", "/dev/stdout", "output file (JSON)") flag.Parse() if flags.help { flag.Usage() return } cfg := config.Config{} dataIn, err := ioutil.ReadFile(flags.inFile) if err != nil { stderr("Failed to read: %v", err) os.Exit(1) } if err := yaml.Unmarshal(dataIn, &cfg); err != nil { stderr("Failed to unmarshal input: %v", err) os.Exit(1) } var inCfg interface{} if err := yaml.Unmarshal(dataIn, &inCfg); err != nil { stderr("Failed to unmarshal input: %v", err) os.Exit(1) } if hasUnrecognizedKeys(inCfg, reflect.TypeOf(cfg)) { stderr("Unrecognized keys in input, aborting.") os.Exit(1) } var dataOut []byte if flags.pretty { dataOut, err = json.MarshalIndent(&cfg, "", " ") dataOut = append(dataOut, '\n') } else { dataOut, err = json.Marshal(&cfg) } if err != nil { stderr("Failed to marshal output: %v", err) os.Exit(1) } if err := ioutil.WriteFile(flags.outFile, dataOut, 0640); err != nil { stderr("Failed to write: %v", err) os.Exit(1) } }
func TestHasUnrecognizedKeys(t *testing.T) { tests := []struct { in string unrec bool }{ { in: "ignition_version: 1", unrec: false, }, { in: "ignition_version: 1\npasswd:\n users:\n - name: foobar\n", unrec: false, }, { in: "foo: bar", unrec: true, }, { in: "ignition_version: 1\npasswd:\n users:\n - naem: foobar\n", unrec: true, }, } for i, tt := range tests { var cfg interface{} if err := yaml.Unmarshal([]byte(tt.in), &cfg); err != nil { t.Errorf("%d: unmarshal failed: %v", i, err) continue } if unrec := hasUnrecognizedKeys(cfg, reflect.TypeOf(config.Config{})); unrec != tt.unrec { t.Errorf("%d: expected %v got %v", i, tt.unrec, unrec) } } }
func main() { flag.Parse() if *flagHelp { flag.Usage() os.Exit(1) } cfg := config.Config{} b, err := ioutil.ReadFile(*flagInFile) if err != nil { stderr("Failed to read: %v", err) os.Exit(2) } if err := yaml.Unmarshal(b, &cfg); err != nil { stderr("Failed to unmarshal input: %v", err) os.Exit(3) } b, err = json.Marshal(&cfg) if err != nil { stderr("Failed to marshal output: %v", err) os.Exit(4) } if err := ioutil.WriteFile(*flagOutFile, b, 0640); err != nil { stderr("Failed to write: %v", err) os.Exit(5) } os.Exit(0) }
func TestDevicePathUnmarshalYAML(t *testing.T) { type in struct { data string } type out struct { device DevicePath err error } tests := []struct { in in out out }{ { in: in{data: `"/path"`}, out: out{device: DevicePath("/path")}, }, { in: in{data: `"bad"`}, out: out{device: DevicePath("bad"), err: errors.New("device path not absolute")}, }, } for i, test := range tests { var device DevicePath err := yaml.Unmarshal([]byte(test.in.data), &device) if !reflect.DeepEqual(test.out.err, err) { t.Errorf("#%d: bad error: want %v, got %v", i, test.out.err, err) } if !reflect.DeepEqual(test.out.device, device) { t.Errorf("#%d: bad device: want %#v, got %#v", i, test.out.device, device) } } }
func TestMkfsOptionsUnmarshalYAML(t *testing.T) { type in struct { data string } type out struct { options MkfsOptions err error } tests := []struct { in in out out }{ { in: in{data: `["--label=ROOT"]`}, out: out{options: MkfsOptions([]string{"--label=ROOT"})}, }, } for i, test := range tests { var options MkfsOptions err := yaml.Unmarshal([]byte(test.in.data), &options) if !reflect.DeepEqual(test.out.err, err) { t.Errorf("#%d: bad error: want %v, got %v", i, test.out.err, err) } if !reflect.DeepEqual(test.out.options, options) { t.Errorf("#%d: bad device: want %#v, got %#v", i, test.out.options, options) } } }
func TestFilesystemFormatUnmarshalYAML(t *testing.T) { type in struct { data string } type out struct { format FilesystemFormat err error } tests := []struct { in in out out }{ { in: in{data: `"ext4"`}, out: out{format: FilesystemFormat("ext4")}, }, { in: in{data: `"bad"`}, out: out{format: FilesystemFormat("bad"), err: errors.New("invalid filesystem format")}, }, } for i, test := range tests { var format FilesystemFormat err := yaml.Unmarshal([]byte(test.in.data), &format) if !reflect.DeepEqual(test.out.err, err) { t.Errorf("#%d: bad error: want %v, got %v", i, test.out.err, err) } if !reflect.DeepEqual(test.out.format, format) { t.Errorf("#%d: bad device: want %#v, got %#v", i, test.out.format, format) } } }
func TestNetworkdUnitNameUnmarshalYAML(t *testing.T) { type in struct { data string } type out struct { unit NetworkdUnitName err error } tests := []struct { in in out out }{ { in: in{data: `"test.network"`}, out: out{unit: NetworkdUnitName("test.network")}, }, { in: in{data: `"test.link"`}, out: out{unit: NetworkdUnitName("test.link")}, }, { in: in{data: `"test.netdev"`}, out: out{unit: NetworkdUnitName("test.netdev")}, }, { in: in{data: `"test.blah"`}, out: out{err: errors.New("invalid networkd unit extension")}, }, } for i, test := range tests { var unit NetworkdUnitName err := yaml.Unmarshal([]byte(test.in.data), &unit) if !reflect.DeepEqual(test.out.err, err) { t.Errorf("#%d: bad error: want %v, got %v", i, test.out.err, err) } if err != nil { continue } if !reflect.DeepEqual(test.out.unit, unit) { t.Errorf("#%d: bad unit: want %#v, got %#v", i, test.out.unit, unit) } } }
func TestFileModeUnmarshalYAML(t *testing.T) { type in struct { data string } type out struct { mode FileMode err error } tests := []struct { in in out out }{ { in: in{data: `0644`}, out: out{mode: FileMode(0644)}, }, { in: in{data: `0420`}, out: out{mode: FileMode(0420)}, }, { in: in{data: `017777`}, out: out{mode: FileMode(017777), err: ErrFileIllegalMode}, }, } for i, test := range tests { var mode FileMode err := yaml.Unmarshal([]byte(test.in.data), &mode) if !reflect.DeepEqual(test.out.err, err) { t.Errorf("#%d: bad error: want %v, got %v", i, test.out.err, err) } if !reflect.DeepEqual(test.out.mode, mode) { t.Errorf("#%d: bad mode: want %#o, got %#o", i, test.out.mode, mode) } } }