github.com/databricks/cli@v0.203.0/bundle/run/output/job_test.go (about)

     1  package output
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/databricks/databricks-sdk-go/service/jobs"
     7  	"github.com/stretchr/testify/assert"
     8  	"github.com/stretchr/testify/require"
     9  )
    10  
    11  func TestSingleTaskJobOutputToString(t *testing.T) {
    12  	taskNotebook := NotebookOutput{
    13  		Result:    "foo",
    14  		Truncated: true,
    15  	}
    16  	myJob := JobOutput{
    17  		TaskOutputs: []TaskOutput{
    18  			{TaskKey: "my_notebook_task", Output: &taskNotebook, EndTime: 0},
    19  		},
    20  	}
    21  
    22  	actual, err := myJob.String()
    23  	require.NoError(t, err)
    24  	expected := "foo\n[truncated...]\n"
    25  	assert.Equal(t, expected, actual)
    26  }
    27  
    28  func TestMultiTaskJobOutputToString(t *testing.T) {
    29  	taskFoo := NotebookOutput{
    30  		Result:    "foo",
    31  		Truncated: true,
    32  	}
    33  	taskBar := LogsOutput{
    34  		Logs:          "bar",
    35  		LogsTruncated: false,
    36  	}
    37  	myJob := JobOutput{
    38  		TaskOutputs: []TaskOutput{
    39  			{TaskKey: "my_bar_task", Output: &taskBar, EndTime: 0},
    40  			{TaskKey: "my_foo_task", Output: &taskFoo, EndTime: 0},
    41  		},
    42  	}
    43  
    44  	actual, err := myJob.String()
    45  	require.NoError(t, err)
    46  
    47  	expected := `Output:
    48  =======
    49  Task my_bar_task:
    50  bar
    51  =======
    52  Task my_foo_task:
    53  foo
    54  [truncated...]
    55  
    56  `
    57  	assert.Equal(t, expected, actual)
    58  }
    59  
    60  func TestTaskJobOutputOrderToString(t *testing.T) {
    61  	taskFoo := NotebookOutput{
    62  		Result: "foo",
    63  	}
    64  	taskBar := LogsOutput{
    65  		Logs: "bar",
    66  	}
    67  	taskBaz := LogsOutput{
    68  		Logs: "baz",
    69  	}
    70  	myJob := JobOutput{
    71  		TaskOutputs: []TaskOutput{
    72  			{TaskKey: "my_baz_task", Output: &taskBaz, EndTime: 1683553233331},
    73  			{TaskKey: "my_bar_task", Output: &taskBar, EndTime: 1683553223508},
    74  			{TaskKey: "my_foo_task", Output: &taskFoo, EndTime: 1683553217598},
    75  		},
    76  	}
    77  
    78  	actual, err := myJob.String()
    79  	require.NoError(t, err)
    80  
    81  	expected := `Output:
    82  =======
    83  Task my_foo_task:
    84  foo
    85  =======
    86  Task my_bar_task:
    87  bar
    88  =======
    89  Task my_baz_task:
    90  baz
    91  `
    92  	assert.Equal(t, expected, actual)
    93  }
    94  
    95  func TestNotebookOutputToRunOutput(t *testing.T) {
    96  	jobOutput := &jobs.RunOutput{
    97  		NotebookOutput: &jobs.NotebookOutput{
    98  			Result:    "foo",
    99  			Truncated: true,
   100  		},
   101  		Logs:          "hello :)",
   102  		LogsTruncated: true,
   103  	}
   104  	actual := toRunOutput(jobOutput)
   105  
   106  	expected := &NotebookOutput{
   107  		Result:    "foo",
   108  		Truncated: true,
   109  	}
   110  	assert.Equal(t, expected, actual)
   111  }
   112  
   113  func TestDbtOutputToRunOutput(t *testing.T) {
   114  	jobOutput := &jobs.RunOutput{
   115  		DbtOutput: &jobs.DbtOutput{
   116  			ArtifactsLink: "foo",
   117  		},
   118  		Logs: "hello :)",
   119  	}
   120  	actual := toRunOutput(jobOutput)
   121  
   122  	expected := &DbtOutput{
   123  		ArtifactsLink: "foo",
   124  	}
   125  	assert.Equal(t, expected, actual)
   126  }
   127  
   128  func TestSqlOutputToRunOutput(t *testing.T) {
   129  	jobOutput := &jobs.RunOutput{
   130  		SqlOutput: &jobs.SqlOutput{
   131  			QueryOutput: &jobs.SqlQueryOutput{
   132  				OutputLink: "foo",
   133  			},
   134  		},
   135  		Logs: "hello :)",
   136  	}
   137  	actual := toRunOutput(jobOutput)
   138  
   139  	expected := &SqlOutput{
   140  		QueryOutput: &jobs.SqlQueryOutput{
   141  			OutputLink: "foo",
   142  		},
   143  	}
   144  	assert.Equal(t, expected, actual)
   145  }
   146  
   147  func TestLogOutputToRunOutput(t *testing.T) {
   148  	jobOutput := &jobs.RunOutput{
   149  		Logs:          "hello :)",
   150  		LogsTruncated: true,
   151  	}
   152  	actual := toRunOutput(jobOutput)
   153  
   154  	expected := &LogsOutput{
   155  		Logs:          "hello :)",
   156  		LogsTruncated: true,
   157  	}
   158  	assert.Equal(t, expected, actual)
   159  }