github_test.go

// Code generated by Fern. DO NOT EDIT.

package generatorcli

import (
	json "encoding/json"
	assert "github.com/stretchr/testify/assert"
	require "github.com/stretchr/testify/require"
	testing "testing"
)

func TestSettersGitHubConfig(t *testing.T) {
	t.Run("SetSourceDirectory", func(t *testing.T) {
		obj := &GitHubConfig{}
		var fernTestValueSourceDirectory string
		obj.SetSourceDirectory(fernTestValueSourceDirectory)
		assert.Equal(t, fernTestValueSourceDirectory, obj.SourceDirectory)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetUri", func(t *testing.T) {
		obj := &GitHubConfig{}
		var fernTestValueUri string
		obj.SetUri(fernTestValueUri)
		assert.Equal(t, fernTestValueUri, obj.Uri)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetToken", func(t *testing.T) {
		obj := &GitHubConfig{}
		var fernTestValueToken string
		obj.SetToken(fernTestValueToken)
		assert.Equal(t, fernTestValueToken, obj.Token)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetBranch", func(t *testing.T) {
		obj := &GitHubConfig{}
		var fernTestValueBranch *string
		obj.SetBranch(fernTestValueBranch)
		assert.Equal(t, fernTestValueBranch, obj.Branch)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersGitHubConfig(t *testing.T) {
	t.Run("GetSourceDirectory", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GitHubConfig{}
		var expected string
		obj.SourceDirectory = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetSourceDirectory(), "getter should return the property value")
	})

	t.Run("GetSourceDirectory_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *GitHubConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetSourceDirectory() // Should return zero value
	})

	t.Run("GetUri", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GitHubConfig{}
		var expected string
		obj.Uri = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetUri(), "getter should return the property value")
	})

	t.Run("GetUri_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *GitHubConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetUri() // Should return zero value
	})

	t.Run("GetToken", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GitHubConfig{}
		var expected string
		obj.Token = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetToken(), "getter should return the property value")
	})

	t.Run("GetToken_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *GitHubConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetToken() // Should return zero value
	})

	t.Run("GetBranch", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GitHubConfig{}
		var expected *string
		obj.Branch = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetBranch(), "getter should return the property value")
	})

	t.Run("GetBranch_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GitHubConfig{}
		obj.Branch = nil

		// Act & Assert
		assert.Nil(t, obj.GetBranch(), "getter should return nil when property is nil")
	})

	t.Run("GetBranch_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *GitHubConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetBranch() // Should return zero value
	})

}

func TestSettersMarkExplicitGitHubConfig(t *testing.T) {
	t.Run("SetSourceDirectory_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GitHubConfig{}
		var fernTestValueSourceDirectory string

		// Act
		obj.SetSourceDirectory(fernTestValueSourceDirectory)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetUri_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GitHubConfig{}
		var fernTestValueUri string

		// Act
		obj.SetUri(fernTestValueUri)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetToken_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GitHubConfig{}
		var fernTestValueToken string

		// Act
		obj.SetToken(fernTestValueToken)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetBranch_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GitHubConfig{}
		var fernTestValueBranch *string

		// Act
		obj.SetBranch(fernTestValueBranch)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

}

func TestJSONMarshalingGitHubConfig(t *testing.T) {
	t.Run("MarshalUnmarshal", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GitHubConfig{}

		// Act - Marshal to JSON
		data, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed")
		assert.NotNil(t, data, "marshaled data should not be nil")
		assert.NotEmpty(t, data, "marshaled data should not be empty")

		// Unmarshal back and verify round-trip
		var unmarshaled GitHubConfig
		err = json.Unmarshal(data, &unmarshaled)
		assert.NoError(t, err, "round-trip unmarshal should succeed")
	})

	t.Run("UnmarshalInvalidJSON", func(t *testing.T) {
		t.Parallel()
		var obj GitHubConfig
		err := json.Unmarshal([]byte(`{invalid json}`), &obj)
		assert.Error(t, err, "unmarshaling invalid JSON should return an error")
	})

	t.Run("UnmarshalEmptyObject", func(t *testing.T) {
		t.Parallel()
		var obj GitHubConfig
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

func TestStringGitHubConfig(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &GitHubConfig{}
		result := obj.String()
		assert.NotEmpty(t, result, "String() should return a non-empty representation")
	})

	t.Run("StringMethod_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *GitHubConfig
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestExtraPropertiesGitHubConfig(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &GitHubConfig{}
		// Should not panic when calling GetExtraProperties()
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("GetExtraProperties() panicked: %v", r)
			}
		}()
		extraProps := obj.GetExtraProperties()
		// Result can be nil or an empty/non-empty map
		_ = extraProps
	})

	t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *GitHubConfig
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}